Variáveis#

Introdução#

As variáveis ​​armazenam dados e permitem reutilizá-los e manipulá-los em todo o seu programa. C++ é uma linguagem estaticamente tipada, o que significa que tem de declarar o tipo de uma variável explicitamente quando a cria. O tipo não pode ser alterado após a declaração. Por exemplo:

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

O C++ também é fortemente tipado, o que significa que não pode realizar operações em tipos incompatíveis sem conversão explícita. Por exemplo:

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 os tipos de variáveis ​​comuns em C++. Embora não seja uma lista exaustiva, abrange os tipos que provavelmente irá utilizar na prática.

  • Variáveis ​​locais — Declaradas dentro de uma função e utilizadas apenas dentro desse âmbito; melhor para valores temporários ou isolados.

  • Variáveis ​​globais — Declaradas fora de qualquer função e utilizadas em todo o projeto; boas para partilhar dados entre funções.

  • Inteiro — Números inteiros utilizados para contagem, distâncias ou qualquer coisa sem decimais.

  • Duplo — Números decimais de alta precisão para cálculos matemáticos que exigem exatidão.

  • Float — Números decimais de precisão padrão, úteis para medições ou cálculos.

  • String estilo C — Valores de texto, utilizados para mensagens, etiquetas ou visualização de saída legível.

  • Booleano (bool) — true ou false valores para lógica e tomada de decisão.

  • Arrays — Colecções de tamanho fixo de elementos do mesmo tipo.

  • Matrizes 2D — Matrizes de matrizes; ideal para representar linhas, grelhas ou dados sob a forma de tabela.

  • Const — Uma variável declarada com const não pode ser modificada.

Declarar e atribuir um valor a uma variável#

Para criar uma variável em C++, deve declarar o seu tipo seguido do nome da variável e, opcionalmente, atribuir um valor utilizando o operador =:

int distance = 100;

Ao nomear uma variável, devem ser observadas as seguintes regras:

  • O nome não pode conter caracteres especiais (por exemplo, um ponto de exclamação).

  • O nome não pode começar por um número.

  • O nome não pode conter espaços.

  • O nome não pode entrar em conflito com os objetos VEXcode predefinidos (por exemplo, Drivetrain).

  • O nome não pode ser uma palavra-chave reservada do C++ (por exemplo, int, for, etc.).

  • Os nomes das variáveis ​​diferem entre maiúsculas e minúsculas (por exemplo, Distance e distance são variáveis ​​diferentes).

Local Variables#

As variáveis ​​locais são definidas dentro de uma função ou bloco de código. Só são acessíveis no âmbito dessa função ou bloco e não são visíveis fora dele.

Defina a função (fora de int main())

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

Chame a função 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();
}

As variáveis ​​locais são normalmente utilizadas para armazenar valores temporários que são relevantes apenas dentro de uma função específica ou parte do programa.

Global Variables#

As variáveis ​​globais são definidas fora de qualquer função ou bloco. Podem ser acedidas e lidas em qualquer lugar do programa, incluindo dentro de funções.

Nota: As variáveis ​​globais são acessíveis a partir de qualquer ponto do programa, o que pode ser conveniente para partilhar dados entre funções. No entanto, depender demasiado das variáveis ​​globais pode levar a efeitos secundários indesejados, uma vez que alterações na variável numa parte do programa podem afetar outras partes de forma imprevisível. Por este motivo, as variáveis ​​locais são geralmente preferidas sempre que possível, uma vez que limitam o âmbito de uma variável à função específica onde é definida. Isto reduz a probabilidade de conflitos e facilita a depuração.

Defina a função (fora 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();
}

Chame a função 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);
}

Em C++, as variáveis ​​globais podem ser acedidas e modificadas diretamente a partir do interior das funções sem a necessidade de palavras-chave especiais. No entanto, se tiver uma variável local com o mesmo nome, pode utilizar o operador de resolução de âmbito :: para aceder à variável global.

Defina a função (fora 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();
}

Chame a função 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 dados#

O C++ suporta diversos tipos de dados que podem ser armazenados em variáveis. Alguns tipos podem ser reatribuídos, enquanto outros permitem que elementos individuais sejam modificados. Abaixo estão os tipos mais utilizados:

Integer#

Um número inteiro (int) é um número inteiro.

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#

Um double é um número decimal de alta precisão (normalmente 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#

Um float armazena números decimais. Na maioria dos projetos VEX, doubles são preferidos em relação a floats, a menos que a utilização de memória seja uma preocupação.

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#

Uma string no estilo C (char variable_name[]) é uma sequência de caracteres armazenada num vetor de caracteres. As strings do estilo C devem ser suficientemente grandes para armazenar o texto e um 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#

Um Booleano (bool) representa true ou 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...");
  }
}

Os valores booleanos podem ser alterados em qualquer ponto do projeto.

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 são coleções de tamanho fixo de elementos do mesmo tipo, começando no índice 0. É uma boa prática saber o comprimento do array e declará-lo no momento da sua criação.

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#

Uma matriz 2D é normalmente utilizada para representar grelhas, tabelas ou arrays. Cada linha representa um agrupamento específico de dados.

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

Pode modificar elementos específicos dentro de uma 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#

Uma variável declarada com const não pode ser modificada após ser inicializada.

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