Zmienne#

Wstęp#

Zmienne przechowują dane i umożliwiają ich ponowne wykorzystanie oraz manipulowanie nimi w całym programie. C++ jest językiem statycznie typowanym, ​​co oznacza, że ​​typ zmiennej należy jawnie zadeklarować podczas jej tworzenia. Typu nie można zmienić po deklaracji. Na przykład:

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

Język C++ jest również silnie typizowany, co oznacza, że ​​nie można wykonywać operacji na niekompatybilnych typach bez jawnej konwersji. Na przykład:

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

To API wyjaśnia popularne typy zmiennych w C++. Choć nie jest to wyczerpująca lista, obejmuje typy, których najczęściej będziesz używać w praktyce.

  • Zmienne lokalne — Deklarowane wewnątrz funkcji i używane tylko w jej zasięgu; najlepiej sprawdzają się w przypadku wartości tymczasowych lub izolowanych.

  • Zmienne globalne — Deklarowane poza jakąkolwiek funkcją i używane w całym projekcie; przydatne do udostępniania danych między funkcjami.

  • Integer — Liczby całkowite używane do liczenia, określania odległości lub czegokolwiek bez części dziesiętnych.

  • Double — Liczby dziesiętne o wysokiej precyzji do obliczeń matematycznych wymagających dokładności.

  • Float — Liczby dziesiętne o standardowej precyzji, przydatne do pomiarów i obliczeń.

  • Ciąg w stylu C — Wartości tekstowe używane w wiadomościach, etykietach lub do wyświetlania czytelnych wyników.

  • Boolean (bool) — true lub false wartości dla logiki i podejmowania decyzji.

  • Tablice — Kolekcje o stałym rozmiarze zawierające elementy tego samego typu.

  • Tablice 2D — Tablice tablic; idealne do reprezentowania wierszy, siatek lub danych w formie tabeli.

  • Const — Zmienna zadeklarowana za pomocą const const nie może być modyfikowana.

Deklarowanie i przypisywanie zmiennej#

Aby utworzyć zmienną w języku C++, należy zadeklarować jej typ, a następnie nazwę zmiennej i opcjonalnie przypisać jej wartość za pomocą operatora =:

int distance = 100;

Podczas nadawania nazw zmiennej należy przestrzegać następujących zasad:

  • Nazwa nie może zawierać znaków specjalnych (np. wykrzyknika).

  • Nazwa nie może zaczynać się od cyfry.

  • W nazwie nie można używać spacji.

  • Nazwa nie może kolidować z predefiniowanymi obiektami VEXcode (na przykład Drivetrain).

  • Nazwa nie może być zarezerwowanym słowem kluczowym języka C++ (np. int, foritd.).

  • Nazwy zmiennych uwzględniają wielkość liter (np. Distance i distance to różne zmienne).

Local Variables#

Zmienne lokalne są definiowane wewnątrz funkcji lub bloku kodu. Są dostępne tylko w zakresie tej funkcji lub bloku i nie są widoczne poza nim.

Zdefiniuj funkcję (poza int main())

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

Wywołaj funkcję wewnątrz int main()

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

  // Begin project code
  show_local();
}

Zmiennych lokalnych powszechnie używa się do przechowywania wartości tymczasowych, które są istotne tylko w obrębie konkretnej funkcji lub części programu.

Global Variables#

Zmienne globalne są definiowane poza dowolną funkcją lub blokiem. Można do nich uzyskać dostęp i odczytać je w dowolnym miejscu programu, również wewnątrz funkcji.

Uwaga: Zmienne globalne są dostępne z dowolnego miejsca w programie, co ułatwia udostępnianie danych między funkcjami. Jednak nadmierne korzystanie ze zmiennych globalnych może prowadzić do niezamierzonych efektów ubocznych, ponieważ zmiany zmiennej w jednej części programu mogą w nieprzewidywalny sposób wpłynąć na inne części. Z tego powodu, zmienne lokalne są zazwyczaj preferowane, gdy tylko jest to możliwe, ponieważ ograniczają zakres zmiennej do konkretnej funkcji, w której jest zdefiniowana. Zmniejsza to prawdopodobieństwo konfliktów i ułatwia debugowanie.

Zdefiniuj funkcję (poza 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();
}

Wywołaj funkcję wewnątrz 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);
}

W C++ zmienne globalne są dostępne bezpośrednio i można je modyfikować z poziomu funkcji bez użycia specjalnych słów kluczowych. Jeśli jednak istnieje zmienna lokalna o tej samej nazwie, można użyć operatora rozwiązania zakresu :: , aby uzyskać do niej dostęp.

Zdefiniuj funkcję (poza 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();
}

Wywołaj funkcję wewnątrz 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();
}

Typy danych#

C++ obsługuje kilka typów danych, które można przechowywać w zmiennych. Niektóre typy można ponownie przypisać, inne zaś pozwalają na modyfikację poszczególnych elementów. Poniżej przedstawiono najczęściej używane typy:

Integer#

Liczba całkowita (int) jest liczbą całkowitą.

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#

Double to liczba dziesiętna o wysokiej precyzji (zwykle 64-bitowa).

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#

Float przechowuje liczby dziesiętne. W większości projektów VEX preferowane są double zamiast float, chyba że zużycie pamięci jest istotne.

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#

String w stylu C (char variable_name[]) to sekwencja znaków przechowywana w tablicy znaków. Ciągi w stylu C muszą być wystarczająco długie, aby pomieścić tekst i terminator null.

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#

Wartość Boolean (bool) oznacza true lub 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...");
  }
}

Wartości logiczne można zmieniać w dowolnym momencie projektu.

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#

Tablice to zbiory elementów tego samego typu o stałym rozmiarze, rozpoczynające się od indeksu 0. Dobrą praktyką jest znajomość długości tablicy i zadeklarowanie jej w momencie tworzenia.

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#

Tablica 2D jest powszechnie używana do reprezentowania siatek, tabel lub macierzy. Każdy wiersz reprezentuje określoną grupę danych.

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

Można modyfikować konkretne elementy w tablicy 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#

Zmienna zadeklarowana za pomocą const nie może zostać zmodyfikowana po zainicjowaniu.

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