Variables#

Introducción#

Las variables almacenan datos y le permiten reutilizarlos y manipularlos a lo largo de su programa. C++ es un lenguaje * de tipo estático*, lo que significa que debe declarar el tipo de una variable explícitamente al crearla. El tipo no se puede cambiar después de la declaración. Por ejemplo:

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++ también está fuertemente tipado, lo que significa que no puede realizar operaciones en tipos incompatibles sin una conversión explícita. Por ejemplo:

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

Esta API explica los tipos de variables comunes en C++. Si bien no es una lista exhaustiva, cubre los tipos que es más probable que uses en la práctica.

  • Variables locales: se declara dentro de una función y solo se usa dentro de ese alcance; es mejor para valores temporales o aislados.

  • Variables globales — Declaradas fuera de cualquier función y utilizadas a lo largo del proyecto; son buenas para compartir datos entre funciones.

  • Integer: números enteros utilizados para contar, distancias o cualquier cosa sin decimales.

  • Doble — Números decimales de alta precisión para cálculos matemáticos que requieren precisión.

  • Float — Números decimales de precisión estándar, útiles para mediciones o cálculos.

  • C-style String — Valores de texto, utilizados para mensajes, etiquetas o para mostrar una salida legible.

  • Booleano (bool) — true o false valores para lógica y toma de decisiones.

  • Arrays — Colecciones de tamaño fijo de elementos del mismo tipo.

  • Matrices 2D — Matrices de matrices; ideales para representar filas, cuadrículas o datos tipo tabla.

  • Const — Una variable declarada con const no se puede modificar.

Declarar y asignar una variable#

Para crear una variable en C++, debe declarar su tipo seguido del nombre de la variable, luego opcionalmente asignar un valor usando el operador =:

int distance = 100;

Al nombrar una variable, se deben cumplir las siguientes reglas:

  • El nombre no puede contener caracteres especiales (por ejemplo, un signo de exclamación).

  • El nombre no puede comenzar con un número.

  • El nombre no puede usar espacios.

  • El nombre no puede entrar en conflicto con objetos VEXcode predefinidos (por ejemplo, Drivetrain).

  • El nombre no puede ser una palabra clave reservada de C++ (por ejemplo, int, for , etc.).

  • Los nombres de las variables distinguen entre mayúsculas y minúsculas (por ejemplo, Distance y distance son variables diferentes).

Local Variables#

Las variables locales se definen dentro de una función o bloque de código. Solo son accesibles dentro del alcance de esa función o bloque y no son visibles fuera de él.

Definir la función (fuera de int main())

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

Llamar a la función dentro 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();
}

Las variables locales se utilizan comúnmente para almacenar valores temporales que solo son relevantes dentro de una función específica o parte del programa.

Global Variables#

Las variables globales se definen fuera de cualquier función o bloque. Se puede acceder a ellos y leerlos * en cualquier lugar* del programa, incluidas las funciones internas.

Nota:* * Las variables globales son accesibles desde cualquier parte del programa, lo que puede hacer que sean convenientes para compartir datos entre funciones. Sin embargo, depender en gran medida de variables globales puede provocar efectos secundarios no deseados, ya que los cambios en la variable en una parte del programa pueden afectar a otras partes de manera impredecible. Por esta razón, generalmente se prefieren las variables locales * * cuando es posible, ya que limitan el alcance de una variable a la función específica donde se define. Esto reduce la probabilidad de conflictos y facilita la depuración.

Definir la función (fuera 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();
}

Llamar a la función dentro 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++, se puede acceder directamente a las variables globales y modificarlas desde dentro de las funciones sin palabras clave especiales. Sin embargo, si tiene una variable local con el mismo nombre, puede usar el operador de resolución de alcance :: para acceder a la variable global.

Definir la función (fuera 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();
}

Llamar a la función dentro 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();
}

Tipos de datos#

C++ admite varios tipos de datos que se pueden almacenar en variables. Algunos tipos se pueden reasignar, mientras que otros permiten modificar elementos individuales. A continuación se presentan los tipos más utilizados:

Integer#

Un entero (int) es un número entero.

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 doble es un número decimal con alta precisión (típicamente de 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 flotador almacena números decimales. En la mayoría de los proyectos VEX, se prefieren los dobles a los * * flotantes * * a menos que el uso de la memoria sea una preocupación.

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#

Una * * cadena * * de estilo C (char variable_name[]) es una secuencia de caracteres almacenados en una matriz de caracteres. Las cadenas de estilo C deben ser lo suficientemente grandes como para almacenar el texto y un terminador nulo.

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 booleano (bool) representa true o 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...");
  }
}

Los booleanos se pueden cambiar en cualquier punto del proyecto.

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#

Las matrices son colecciones de tamaño fijo de elementos del mismo tipo, que comienzan en el índice 0. Es una buena práctica conocer la longitud de la matriz y declarar en el momento de la creación.

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#

Una matriz 2D se usa comúnmente para representar cuadrículas, tablas o matrices. Cada fila representa una agrupación específica de datos.

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

Puede modificar elementos específicos dentro de una matriz 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#

Una variable declarada con const no se puede modificar después de que se inicializa.

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);
}
En esta página