Variabelen#

Invoering#

Variabelen slaan gegevens op en stellen je in staat deze in je programma te hergebruiken en te manipuleren. C++ is een statisch getypeerde taal, wat betekent dat je het type van een variabele expliciet moet declareren wanneer je deze aanmaakt. Het type kan na declaratie niet meer worden gewijzigd. Bijvoorbeeld:

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++ is ook sterk getypeerd, wat betekent dat je geen bewerkingen kunt uitvoeren op incompatibele typen zonder expliciete conversie. Bijvoorbeeld:

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

Deze API legt veelvoorkomende variabeletypen in C++ uit. Hoewel het geen complete lijst is, behandelt het de typen die je in de praktijk waarschijnlijk het meest zult gebruiken.

  • Lokale variabelen — Gedeclareerd binnen een functie en alleen gebruikt binnen dat bereik; het meest geschikt voor tijdelijke of geïsoleerde waarden.

  • Globale variabelen — Deze worden buiten elke functie gedeclareerd en in het hele project gebruikt; handig voor het delen van gegevens tussen functies.

  • Integer — Hele getallen die gebruikt worden voor tellen, afstanden of alles zonder decimalen.

  • Double — Zeer nauwkeurige decimale getallen voor wiskundige berekeningen die precisie vereisen.

  • Float — Decimale getallen met standaardprecisie, handig voor metingen of berekeningen.

  • C-stijl String — Tekstwaarden, gebruikt voor berichten, labels of het weergeven van leesbare uitvoer.

  • Booleaanse waarde (bool) — true of false waarden voor logica en besluitvorming.

  • Arrays — Verzamelingen van elementen van hetzelfde type met een vaste grootte.

  • 2D-arrays — Arrays van arrays; ideaal voor het weergeven van rijen, roosters of tabelachtige gegevens.

  • Const — Een variabele die is gedeclareerd met const kan niet worden gewijzigd.

Een variabele declareren en toewijzen#

Om een ​​variabele in C++ te creëren, moet je eerst het type declareren, gevolgd door de variabelenaam. Je kunt er vervolgens optioneel een waarde aan toewijzen met behulp van de operator =:

int distance = 100;

Bij het benoemen van een variabele moeten de volgende regels in acht worden genomen:

  • De naam mag geen speciale tekens bevatten (bijvoorbeeld een uitroepsteken).

  • De naam mag niet met een cijfer beginnen.

  • De naam mag geen spaties bevatten.

  • De naam mag niet conflicteren met vooraf gedefinieerde VEXcode-objecten (bijvoorbeeld Drivetrain).

  • De naam mag geen gereserveerd C+±sleutelwoord zijn (bijv. int, for, enz.).

  • Variabelnamen zijn hoofdlettergevoelig (bijvoorbeeld: Distance en distance zijn verschillende variabelen).

Local Variables#

Lokale variabelen worden gedefinieerd binnen een functie of codeblok. Ze zijn alleen toegankelijk binnen het bereik van die functie of dat blok en zijn niet zichtbaar daarbuiten.

Definieer de functie (buiten int main())

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

Roep de functie aan binnen 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 variabelen worden vaak gebruikt om tijdelijke waarden op te slaan die alleen relevant zijn binnen een specifieke functie of een deel van het programma.

Global Variables#

Globale variabelen worden gedefinieerd buiten elke functie of codeblok. Ze kunnen overal in het programma worden benaderd en gelezen, ook binnen functies.

Opmerking: Globale variabelen zijn overal in het programma toegankelijk, waardoor ze handig kunnen zijn voor het delen van gegevens tussen functies. Echter, overmatig gebruik van globale variabelen kan leiden tot onbedoelde neveneffecten, omdat wijzigingen in de variabele in één deel van het programma andere delen onvoorspelbaar kunnen beïnvloeden. Om deze reden hebben lokale variabelen over het algemeen de voorkeur, omdat ze het bereik van een variabele beperken tot de specifieke functie waarin deze is gedefinieerd. Dit verkleint de kans op conflicten en maakt debuggen eenvoudiger.

Definieer de functie (buiten 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();
}

Roep de functie aan binnen 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++ kunnen globale variabelen rechtstreeks vanuit functies worden benaderd en gewijzigd zonder speciale trefwoorden. Als er echter een lokale variabele met dezelfde naam bestaat, kunt u de scope-resolutieoperator :: gebruiken om de globale variabele te benaderen.

Definieer de functie (buiten 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();
}

Roep de functie aan binnen 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();
}

Soorten gegevens#

C++ ondersteunt verschillende gegevenstypen die in variabelen kunnen worden opgeslagen. Sommige typen kunnen opnieuw worden toegewezen, terwijl andere het mogelijk maken om individuele elementen te wijzigen. Hieronder staan ​​de meest gebruikte typen:

Integer#

Een geheel getal (int) is een geheel getal.

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#

Een double is een decimaal getal met een hoge precisie (doorgaans 64-bits).

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#

Een float slaat decimale getallen op. In de meeste VEX-projecten hebben doubles de voorkeur boven floats, tenzij geheugengebruik een probleem is.

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#

Een C-stijl string (char variable_name[]) is een reeks tekens die zijn opgeslagen in een tekenarray. C-stijl strings moeten groot genoeg zijn om de tekst en een null-terminator te bevatten.

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#

Een Booleaanse waarde (bool) staat voor true of false waarden.

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

Booleaanse waarden kunnen op elk moment in het project worden gewijzigd.

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 zijn verzamelingen van elementen van hetzelfde type met een vaste grootte, beginnend bij index 0. Het is goede gewoonte om de lengte van de array te kennen en deze bij het aanmaken te declareren.

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#

Een 2D-array wordt vaak gebruikt om roosters, tabellen of matrices weer te geven. Elke rij vertegenwoordigt een specifieke groepering van gegevens.

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

Je kunt specifieke elementen binnen een 2D-array wijzigen:

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#

Een variabele die is gedeclareerd met const kan niet meer worden gewijzigd nadat deze is geïnitialiseerd.

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