Variables#

Introduction#

Les variables stockent des données et permettent de les réutiliser et de les manipuler dans tout le programme. Le C++ est un langage statiquement typé, ce qui signifie que vous devez déclarer explicitement le type d’une variable lors de sa création. Le type ne peut plus être modifié après sa déclaration. Par exemple :

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

Le C++ est également fortement typé, ce qui signifie que vous ne pouvez pas effectuer d’opérations sur des types incompatibles sans conversion explicite. Par exemple :

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

Cette API explique les types de variables courants en C++. Bien qu’elle ne soit pas exhaustive, elle couvre les types que vous serez le plus susceptible d’utiliser en pratique.

  • Variables locales — Déclarées à l’intérieur d’une fonction et utilisées uniquement dans cette portée ; idéales pour les valeurs temporaires ou isolées.

  • Variables globales — Déclarées en dehors de toute fonction et utilisées dans tout le projet ; utiles pour partager des données entre les fonctions.

  • Entier — Nombres entiers utilisés pour le comptage, les distances ou tout ce qui n’a pas de décimales.

  • Double — Nombres décimaux de haute précision pour les calculs mathématiques nécessitant de la précision.

  • Flottant — Nombres décimaux de précision standard, utiles pour les mesures ou les calculs.

  • Chaîne de caractères de style C — Valeurs de texte, utilisées pour les messages, les étiquettes ou l’affichage d’une sortie lisible.

  • Booléen (bool) — true ou false valeurs pour la logique et la prise de décision.

  • Tableaux — Collections de taille fixe d’éléments du même type.

  • Tableaux 2D — Tableaux de tableaux ; idéal pour représenter des lignes, des grilles ou des données de type tableau.

  • Const — Une variable déclarée avec const ne peut pas être modifiée.

Déclaration et affectation d’une variable#

Pour créer une variable en C++, vous devez déclarer son type suivi du nom de la variable, puis éventuellement lui assigner une valeur à l’aide de l’opérateur = :

int distance = 100;

Lors de la dénomination d’une variable, les règles suivantes doivent être respectées :

  • Le nom ne peut pas contenir de caractères spéciaux (par exemple, un point d’exclamation).

  • Le nom ne peut pas commencer par un chiffre.

  • Le nom ne peut pas contenir d’espaces.

  • Le nom ne peut pas entrer en conflit avec des objets VEXcode prédéfinis (par exemple, Drivetrain).

  • Le nom ne peut pas être un mot-clé réservé C++ (par exemple, int, for, etc.).

  • Les noms de variables sont sensibles à la casse (par exemple, Distance et distance sont des variables différentes).

Local Variables#

Les variables locales sont définies à l’intérieur d’une fonction ou d’un bloc de code. Elles ne sont accessibles que dans la portée de cette fonction ou de ce bloc et ne sont pas visibles en dehors de celui-ci.

Définissez la fonction (en dehors de int main())

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

Appelez la fonction à l’intérieur de int main()

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

  // Begin project code
  show_local();
}

Les variables locales sont couramment utilisées pour stocker des valeurs temporaires qui ne sont pertinentes que dans une fonction ou une partie spécifique du programme.

Global Variables#

Les variables globales sont définies en dehors de toute fonction ou bloc. Elles peuvent être consultées et lues partout dans le programme, y compris à l’intérieur des fonctions.

Remarque : Les variables globales sont accessibles de partout dans le programme, ce qui facilite le partage de données entre fonctions. Cependant, leur utilisation excessive peut entraîner des effets indésirables, car toute modification apportée à une variable dans une partie du programme peut affecter d’autres parties de manière imprévisible. C’est pourquoi, lorsque cela est possible, on privilégie généralement les variables locales, car elles limitent la portée d’une variable à la fonction spécifique où elle est définie. Cela réduit le risque de conflits et simplifie le débogage.

Définissez la fonction (en dehors de 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();
}

Appelez la fonction à l’intérieur de 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);
}

En C++, les variables globales sont directement accessibles et modifiables depuis l’intérieur des fonctions, sans aucun mot-clé particulier. Cependant, si une variable locale porte le même nom, l’opérateur de résolution de portée :: permet d’accéder à la variable globale.

Définissez la fonction (en dehors de 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();
}

Appelez la fonction à l’intérieur de 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();
}

Types de données#

C++ prend en charge plusieurs types de données pouvant être stockées dans des variables. Certains types peuvent être réassignés, tandis que d’autres permettent la modification d’éléments individuels. Voici les types les plus couramment utilisés :

Integer#

Un entier (int) est un nombre entier.

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#

Un double est un nombre décimal de haute précision (généralement 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#

Un type float stocke des nombres décimaux. Dans la plupart des projets VEX, les types double sont préférés aux types float, sauf si l’utilisation de la mémoire est un problème.

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#

Une chaîne de caractères de style C (char variable_name[]) est une séquence de caractères stockée dans un tableau de caractères. Les chaînes de caractères de style C doivent être suffisamment grandes pour contenir le texte et un caractère nul de fin.

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#

Un booléen (bool) représente true ou false valeurs.

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

Les valeurs booléennes peuvent être modifiées à tout moment du projet.

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#

Les tableaux sont des collections d’éléments de même type, de taille fixe, commençant à l’indice 0. Il est recommandé de connaître la longueur du tableau et de la déclarer lors de sa création.

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#

Un tableau 2D est couramment utilisé pour représenter des grilles, des tableaux ou des matrices. Chaque ligne représente un groupement spécifique de données.

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

Vous pouvez modifier des éléments spécifiques au sein d’un tableau 2D :

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#

Une variable déclarée avec const ne peut pas être modifiée après son initialisation.

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);
}
Sur cette page