Változók#

Bevezetés#

A változók tárolják az adatokat, és lehetővé teszik azok újrafelhasználását és manipulálását a programban. A C++ egy statikusan típusos nyelv, ami azt jelenti, hogy a változó típusát explicit módon kell deklarálni a létrehozásakor. A típus a deklarálás után nem módosítható. Például:

int angle = 90;           // angle is an integer
char dist[] = "Distance"; // dist is an array of characters
double steps = 2.5;       // steps is a double

A C++ erősen típusos, ami azt jelenti, hogy nem lehet műveleteket végrehajtani inkompatibilis típusokon explicit konverzió nélkül. Például:

int blocks = 2;              // blocks is an integer
char rings[] = "4";          // rings is a string
int result = blocks + rings; // Creates a compilation error

Ez az API a C+±ban elterjedt változótípusokat ismerteti. Bár nem teljes lista, lefedi azokat a típusokat, amelyeket a gyakorlatban a legnagyobb valószínűséggel használsz.

  • Lokális változók — Függvényen belül deklarálva, és csak az adott hatókörön belül használva; ideiglenes vagy elszigetelt értékekhez a legmegfelelőbb.

  • Globális változók — Függvényeken kívül deklarálhatók, és a projekt során használják; jól használhatók függvények közötti adatmegosztásra.

  • Integer — Egész számok, amelyeket számlálásra, távolságokra vagy tizedesjegyek nélküli bármi másra használnak.

  • Double — Nagy pontosságú decimális számok pontosságot igénylő matematikai számításokhoz.

  • Float — Standard pontosságú decimális számok, hasznosak mérésekhez vagy számításokhoz.

  • C stílusú karakterlánc — Szöveges értékek, üzenetekhez, címkékhez vagy olvasható kimenet megjelenítéséhez használatos.

  • Boolean(bool) — true vagy false érték a logikához és a döntéshozatalhoz.

  • Tömbök — Azonos típusú elemek fix méretű gyűjteményei.

  • 2D tömbök — Tömbök tömbjei; ideális sorok, rácsok vagy táblázatszerű adatok ábrázolására.

  • Const — const konstanssal deklarált változó nem módosítható.

Változó deklarálása és értékadása#

C+±ban változó létrehozásához először a típusát kell megadni, majd a változó nevét, és opcionálisan értéket kell hozzárendelni a = operátorral:

int distance = 100;

Változók elnevezésekor a következő szabályokat kell betartani:

  • A név nem tartalmazhat speciális karaktereket (pl. felkiáltójelet).

  • A név nem kezdődhet számmal.

  • A név nem tartalmazhat szóközöket.

  • A név nem ütközhet előre definiált VEXcode objektumokkal (például: Drivetrain).

  • A név nem lehet C+±ban foglalt kulcsszó (pl. int, forstb.).

  • A változók nevei megkülönböztetik a kis- és nagybetűket (pl. a Distance távolság és distance távolság különböző változók).

Local Variables#

A lokális változók egy függvényen vagy kódblokkon belül vannak definiálva. Csak az adott függvény vagy blokk hatókörén belül érhetők el, azon kívül nem láthatók.

Definiáld a függvényt ( int main())

void show_local() {
  // This variable only exists inside this function
  int angle = 90;
  Brain.Screen.print("%d", angle);
}

Hívjuk meg a függvényt int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Begin project code
  show_local();
}

A lokális változókat általában olyan ideiglenes értékek tárolására használják, amelyek csak egy adott függvényen vagy a program egy részén belül relevánsak.

Global Variables#

A globális változók bármely függvényen vagy blokkon kívül definiálhatók. Hozzáférhetők és olvashatók a program bárhonnan, beleértve a függvényeken belül is.

Megjegyzés: A globális változók a program bármely pontjáról elérhetők, ami kényelmessé teheti az adatok függvények közötti megosztását. A globális változókra való túlzott támaszkodás azonban nem kívánt mellékhatásokhoz vezethet, mivel a változónak a program egyik részében történő módosítása kiszámíthatatlanul befolyásolhatja a többi részt. Emiatt a lokális változókat általában előnyben részesítjük, amikor csak lehetséges, mivel ezek a változó hatókörét arra az adott függvényre korlátozzák, amelyben definiálva van. Ez csökkenti a konfliktusok valószínűségét és megkönnyíti a hibakeresést.

Definiáld a függvényt ( int main())

// The variable is defined outside a function
int angle = 90;

void show_global() {
  // You can access 'angle' inside a function
  Brain.Screen.print("%d", angle);
  Brain.Screen.newLine();
}

Hívjuk meg a függvényt int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Begin project code
  show_global();
  Brain.Screen.print("%d", angle);
}

A C+±ban a globális változók közvetlenül elérhetők és módosíthatók függvényeken belül, speciális kulcsszavak nélkül. Ha azonban van egy azonos nevű lokális változód, akkor a :: hatókör-feloldási operátorral érheted el a globális változót.

Definiáld a függvényt ( int main())

// Define the global variable
int count = 0;

void increase_count() {
  // Global variables can be accessed directly
  count = count + 1;
  Brain.Screen.print("Count: %d", count);
  Brain.Screen.newLine();
}

Hívjuk meg a függvényt int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Begin project code
  increase_count();
  increase_count();
}

Adattípusok#

A C++ számos olyan adattípust támogat, amelyek változókban tárolhatók. Egyes típusok áthelyezhetők, míg mások lehetővé teszik az egyes elemek módosítását. Az alábbiakban a leggyakrabban használt típusok láthatók:

Integer#

Az integer (int) egy egész szám.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  int distance = 100;

  // Move the robot forward for the variable value in mm
  Drivetrain.driveFor(forward, distance, mm);

  // Add to the variable and move forward the new value, 
  // for 200mm total
  wait(1, seconds);
  distance = distance + 100;
  Drivetrain.driveFor(forward, distance, mm);
}

Double#

A double egy nagy pontosságú (általában 64 bites) tizedesvesszős szám.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Store a value with decimal points
  double raw_value = 0.88;

  // Print the decimal value as a percentage
  Brain.Screen.print("%.1f%%", raw_value * 100);
}

Float#

A float decimális számokat tárol. A legtöbb VEX projektben a doubles értékeket részesítjük előnyben a float értékekkel szemben, kivéve, ha a memóriahasználat fontos.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Store a value with decimal points
  float raw_value = 0.88;

  // Print the decimal value as a percentage
  Brain.Screen.print("%.1f%%", raw_value * 100);
}

String#

A C stílusú karakterlánc (char variable_name[]) egy karaktertömbben tárolt karaktersorozat. A C stílusú karakterláncoknak elég nagynak kell lenniük ahhoz, hogy a szöveget és egy null terminátort tároljanak.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Set the variable to a string then print the string
  char message[] = "Ready!";
  Brain.Screen.print(message);
}

Boolean#

A Boolean (bool) true vagy false értéket jelöl.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Set the state of the variable
  bool delivered = false;

  // Print different messages depending on the Boolean.
  if (delivered) {
      Brain.Screen.print("Package delivered!");
  } else {
      Brain.Screen.print("Delivering...");
  }
}

A logikai értékek a projekt bármely pontján módosíthatók.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Print the value of the delivered variable
  bool delivered = false;
  // Print different messages depending on the Boolean.
  if (delivered) {
      Brain.Screen.print("Package delivered!");
  } else {
      Brain.Screen.print("Delivering...");
  }
  wait(2, seconds);

  // Clear the screen and print the value of the variable again
  Brain.Screen.clearScreen();
  Brain.Screen.setCursor(1,1);
  delivered = true;
  // Print different messages depending on the Boolean.
  if (delivered) {
      Brain.Screen.print("Package delivered!");
  } else {
      Brain.Screen.print("Delivering...");
  }
}

Arrays#

A tömbök azonos típusú elemek fix méretű gyűjteményei, a 0. indexszel kezdődően. Jó gyakorlat, ha ismerjük a tömb hosszát, és a létrehozáskor deklaráljuk.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Declare an array of 5 integers
  int distances[5] = {100, 200, 150, 300, 250};

  // Drive and turn 4 times to move the distance of the first four distances of the array
  for (int i = 0; i < 4; i++) {
      Drivetrain.driveFor(forward, distances[i], mm);
      Drivetrain.turnFor(right, 90, degrees);
  }
}

2D Arrays#

A 2D tömböket általában rácsok, táblázatok vagy mátrixok ábrázolására használják. Minden sor egy adott adatcsoportot jelöl.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Assign the values in the matrix 2D array
  int matrix[3][3] = {
    { 0, 1, 2 },
    { 3, 4, 5 },
    { 6, 7, 8 }
  };

  // Loop through each row
  for (int i = 0; i < 3; i++) {
      // Loop through each column in the row
      for (int j = 0; j < 3; j++) {
          Brain.Screen.print("%d, ", matrix[i][j]);
      }
      Brain.Screen.newLine();
  }
}

Módosíthatja a 2D tömbön belüli egyes elemeket:

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Begin project code
  // Assign the values in the matrix 2D array
  int matrix[3][3] = {
    { 0, 1, 2 },
    { 3, 4, 5 },
    { 6, 7, 8 }
  };

  // Modify the color (in column 2) in row 0
  matrix[0][1] = 200;

  // Print the modified row from the matrix 2D array
  for (int j = 0; j < 3; j++) {
      Brain.Screen.print("%d, ", matrix[0][j]);
  }
}

Constant Variables#

Egy const deklarált változó inicializálása után nem módosítható.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  const int maxSpeed = 100;

  // maxSpeed can be used like a normal variable
  Drivetrain.setDriveVelocity(maxSpeed, percent);
}
On this page