Variablen#

Einführung#

Variablen speichern Daten und ermöglichen deren Wiederverwendung und Bearbeitung im gesamten Programm. C++ ist eine statisch typisierte Sprache, d. h. der Typ einer Variablen muss bei ihrer Erstellung explizit deklariert werden. Der Typ kann nach der Deklaration nicht mehr geändert werden. Zum Beispiel:

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++ ist außerdem stark typisiert, was bedeutet, dass Operationen mit inkompatiblen Datentypen nicht ohne explizite Typumwandlung durchgeführt werden können. Zum Beispiel:

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

Diese API erklärt gängige Variablentypen in C++. Die Liste ist zwar nicht vollständig, deckt aber die Typen ab, die Sie in der Praxis am häufigsten verwenden werden.

  • Lokale Variablen — Werden innerhalb einer Funktion deklariert und nur innerhalb dieses Gültigkeitsbereichs verwendet; am besten geeignet für temporäre oder isolierte Werte.

  • Globale Variablen — Werden außerhalb jeder Funktion deklariert und im gesamten Projekt verwendet; gut geeignet, um Daten zwischen Funktionen auszutauschen.

  • Ganzzahl — Ganze Zahlen, die zum Zählen, für Entfernungen oder für alles ohne Dezimalstellen verwendet werden.

  • Double — Hochpräzise Dezimalzahlen für mathematische Berechnungen, die Genauigkeit erfordern.

  • Float — Standardgenaue Dezimalzahlen, nützlich für Messungen oder Berechnungen.

  • C-Style String — Textwerte, die für Meldungen, Beschriftungen oder die Anzeige lesbarer Ausgaben verwendet werden.

  • Boolean (bool) — true oder false Werte für Logik und Entscheidungsfindung.

  • Arrays — Sammlungen von Elementen desselben Typs mit fester Größe.

  • 2D-Arrays — Arrays von Arrays; ideal zur Darstellung von Zeilen, Gittern oder tabellenartigen Daten.

  • Const — Eine mit const deklarierte Variable kann nicht verändert werden.

Deklarieren und Zuweisen einer Variablen#

Um in C++ eine Variable zu erstellen, müssen Sie ihren Typ und anschließend den Variablennamen deklarieren und dann optional mit dem Operator = einen Wert zuweisen:

int distance = 100;

Bei der Benennung einer Variablen müssen folgende Regeln beachtet werden:

  • Der Name darf keine Sonderzeichen enthalten (z. B. kein Ausrufezeichen).

  • Der Name darf nicht mit einer Zahl beginnen.

  • Der Name darf keine Leerzeichen enthalten.

  • Der Name darf nicht mit vordefinierten VEXcode-Objekten in Konflikt stehen (z. B. Drivetrain).

  • Der Name darf kein reserviertes C+±Schlüsselwort sein (z. B. int, forusw.).

  • Bei Variablennamen wird zwischen Groß- und Kleinschreibung unterschieden (z. B. sind Distance und distance unterschiedliche Variablen).

Local Variables#

Lokale Variablen werden innerhalb einer Funktion oder eines Codeblocks definiert. Sie sind nur innerhalb des Gültigkeitsbereichs dieser Funktion oder dieses Blocks zugänglich und außerhalb davon nicht sichtbar.

Definiere die Funktion (außerhalb von int main())

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

Rufe die Funktion innerhalb von int main()

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

  // Begin project code
  show_local();
}

Lokale Variablen werden häufig verwendet, um temporäre Werte zu speichern, die nur innerhalb einer bestimmten Funktion oder eines bestimmten Teils des Programms relevant sind.

Global Variables#

Globale Variablen werden außerhalb jeglicher Funktionen oder Blöcke definiert. Sie können überall im Programm, auch innerhalb von Funktionen, aufgerufen und gelesen werden.

Hinweis: Globale Variablen sind von überall im Programm zugänglich, was die gemeinsame Nutzung von Daten zwischen Funktionen erleichtert. Die häufige Verwendung globaler Variablen kann jedoch zu unbeabsichtigten Nebenwirkungen führen, da Änderungen an einer Variablen in einem Teil des Programms andere Teile unvorhersehbar beeinflussen können. Daher sind lokale Variablen in der Regel vorzuziehen, da sie den Gültigkeitsbereich einer Variablen auf die jeweilige Funktion beschränken, in der sie definiert ist. Dies verringert die Wahrscheinlichkeit von Konflikten und erleichtert die Fehlersuche.

Definiere die Funktion (außerhalb von 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();
}

Rufe die Funktion innerhalb von 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);
}

In C++ können globale Variablen direkt aus Funktionen heraus ohne spezielle Schlüsselwörter aufgerufen und verändert werden. Existiert jedoch eine lokale Variable mit demselben Namen, kann der Bereichsauflösungsoperator :: verwendet werden, um auf die globale Variable zuzugreifen.

Definiere die Funktion (außerhalb von 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();
}

Rufe die Funktion innerhalb von 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();
}

Datentypen#

C++ unterstützt verschiedene Datentypen, die in Variablen gespeichert werden können. Einige Typen lassen sich neu zuweisen, während bei anderen einzelne Elemente verändert werden können. Im Folgenden sind die gebräuchlichsten Typen aufgeführt:

Integer#

Eine ganze Zahl (int) ist eine natürliche Zahl.

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#

Ein double ist eine Dezimalzahl mit hoher Genauigkeit (typischerweise 64 Bit).

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#

Ein float speichert Dezimalzahlen. In den meisten VEX-Projekten werden doubles gegenüber float bevorzugt, es sei denn, der Speicherverbrauch spielt eine Rolle.

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#

Ein C-String (char variable_name[]) ist eine Zeichenfolge, die in einem Zeichenarray gespeichert wird. C-Strings müssen groß genug sein, um den Text und ein Nullbyte aufzunehmen.

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#

Ein Boolescher Wert (bool) repräsentiert true oder false Werte.

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

Boolesche Werte können zu jedem Zeitpunkt im Projekt geändert werden.

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#

Arrays sind Sammlungen von Elementen desselben Typs mit fester Größe, beginnend bei Index 0. Es empfiehlt sich, die Länge des Arrays zu kennen und sie bei der Erstellung anzugeben.

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#

Ein 2D-Array wird häufig zur Darstellung von Gittern, Tabellen oder Matrizen verwendet. Jede Zeile repräsentiert eine bestimmte Datengruppe.

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

Sie können bestimmte Elemente innerhalb eines 2D-Arrays ändern:

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#

Eine mit const deklarierte Variable kann nach ihrer Initialisierung nicht mehr verändert werden.

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