Proměnné#

Zavedení#

Proměnné ukládají data a umožňují vám je znovu používat a manipulovat s nimi v celém programu. C++ je staticky typovaný jazyk, což znamená, že typ proměnné musíte explicitně deklarovat při jejím vytváření. Typ nelze po deklaraci změnit. Například:

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

C++ je také silně typovaný jazyk, což znamená, že nelze provádět operace s nekompatibilními typy bez explicitní konverze. Například:

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

Toto API vysvětluje běžné typy proměnných v C++. I když se nejedná o vyčerpávající seznam, zahrnuje typy, které v praxi nejpravděpodobněji použijete.

  • Lokální proměnné — Deklarované uvnitř funkce a používané pouze v daném rozsahu platnosti; nejvhodnější pro dočasné nebo izolované hodnoty.

  • Globální proměnné — Deklarované mimo jakoukoli funkci a používané v celém projektu; vhodné pro sdílení dat mezi funkcemi.

  • Celé číslo — Celá čísla používaná pro počítání, vzdálenosti nebo cokoli bez desetinných míst.

  • Double — Vysoce přesná desetinná čísla pro matematické výpočty vyžadující přesnost.

  • Float — Desetinná čísla se standardní přesností, užitečná pro měření nebo výpočty.

  • Řetězec ve stylu C — Textové hodnoty používané pro zprávy, popisky nebo zobrazení čitelného výstupu.

  • Boolean (bool) — true nebo false hodnoty pro logiku a rozhodování.

  • Pole — Kolekce prvků stejného typu s pevnou velikostí.

  • 2D pole — Pole polí; ideální pro reprezentaci řádků, mřížek nebo tabulkových dat.

  • Const — Proměnnou deklarovanou s konstantou const nelze upravit.

Deklarace a přiřazení proměnné#

Chcete-li v C++ vytvořit proměnnou, musíte deklarovat její typ následovaný názvem proměnné a poté volitelně přiřadit hodnotu pomocí operátoru =:

int distance = 100;

Při pojmenování proměnné je nutné dodržovat následující pravidla:

  • Název nesmí obsahovat speciální znaky (např. vykřičník).

  • Jméno nemůže začínat číslicí.

  • Název nesmí používat mezery.

  • Název nesmí kolidovat s předdefinovanými objekty VEXcode (například Drivetrain).

  • Název nemůže být rezervované klíčové slovo v C++ (např. int, foratd.).

  • Názvy proměnných rozlišují velká a malá písmena (např. Distance a distance jsou různé proměnné).

Local Variables#

Lokální proměnné jsou definovány uvnitř funkce nebo bloku kódu. Jsou přístupné pouze v rámci dané funkce nebo bloku a nejsou viditelné mimo něj.

Definujte funkci (mimo int main())

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

Zavolejte funkci uvnitř int main()

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

  // Begin project code
  show_local();
}

Lokální proměnné se běžně používají k ukládání dočasných hodnot, které jsou relevantní pouze v rámci určité funkce nebo části programu.

Global Variables#

Globální proměnné jsou definovány vně jakékoli funkce nebo bloku. Lze k nim přistupovat a číst je kdekoli v programu, včetně uvnitř funkcí.

Poznámka: Globální proměnné jsou přístupné z libovolného místa v programu, což je usnadňuje sdílení dat mezi funkcemi. Silné spoléhání se na globální proměnné však může vést k nezamýšleným vedlejším účinkům, protože změny proměnné v jedné části programu mohou nepředvídatelně ovlivnit další části. Z tohoto důvodu se obecně, pokud je to možné, upřednostňují lokální proměnné, protože omezují rozsah proměnné na konkrétní funkci, ve které je definována. To snižuje pravděpodobnost konfliktů a usnadňuje ladění.

Definujte funkci (mimo 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();
}

Zavolejte funkci uvnitř 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);
}

V C++ lze ke globálním proměnným přistupovat a upravovat je přímo z funkcí bez použití speciálních klíčových slov. Pokud však máte lokální proměnnou se stejným názvem, můžete pro přístup k této globální proměnné použít operátor rozlišení rozsahu ::.

Definujte funkci (mimo 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();
}

Zavolejte funkci uvnitř 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();
}

Typy dat#

Jazyk C++ podporuje několik typů dat, které lze ukládat do proměnných. Některé typy lze přeřadit, zatímco jiné umožňují úpravu jednotlivých prvků. Níže jsou uvedeny nejčastěji používané typy:

Integer#

Celé číslo (int) je celé číslo.

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#

Číslo typu double je číslo s vysokou přesností (obvykle 64 bitů) v desetinné čárce.

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#

Číslo typu float ukládá desetinná čísla. Ve většině projektů VEX se upřednostňuje použití typu doubles před float, pokud se nejedná o problém s využitím paměti.

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#

Řetězec ve stylu jazyka C (char variable_name[]) je posloupnost znaků uložená v poli znaků. Řetězce ve stylu jazyka C musí být dostatečně velké pro uložení textu a nulového terminátoru.

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#

Logická hodnota (bool) představuje true nebo false.

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...");
  }
}

Booleovské hodnoty lze změnit kdykoli v projektu.

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#

Pole jsou kolekce prvků stejného typu s pevnou velikostí, počínaje indexem 0. Je vhodné znát délku pole a deklarovat ji při jeho vytváření.

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#

2D pole se běžně používá k reprezentaci mřížek, tabulek nebo matic. Každý řádek představuje specifickou skupinu dat.

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ůžete upravovat konkrétní prvky v rámci 2D pole:

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#

Proměnnou deklarovanou s hodnotou const nelze po inicializaci upravit.

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