Variabler#

Introduktion#

Variabler lagrar data och låter dig återanvända och manipulera den i hela ditt program. C++ är ett statiskt typat språk, vilket innebär att du måste deklarera typen för en variabel explicit när du skapar den. Typen kan inte ändras efter deklaration. Till exempel:

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++ är också starkt typat, vilket innebär att du inte kan utföra operationer på inkompatibla typer utan explicit konvertering. Till exempel:

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

Detta API förklarar vanliga variabeltyper i C++. Även om det inte är en uttömmande lista, täcker det de typer du troligtvis kommer att använda i praktiken.

  • Lokala variabler — Deklareras inuti en funktion och används endast inom det omfånget; bäst för tillfälliga eller isolerade värden.

  • Globala variabler — Deklareras utanför vilken funktion som helst och används i hela projektet; bra för att dela data mellan funktioner.

  • Heltal — Heltal som används för räkning, avstånd eller allt utan decimaler.

  • Dubbel — Högprecisionsdecimaltal för matematiska beräkningar som kräver noggrannhet.

  • Flyttal — Decimaltal med standardprecision, användbara för mätningar eller beräkningar.

  • C-stilsträng — Textvärden, används för meddelanden, etiketter eller för att visa läsbar utdata.

  • Booleskt (bool) — true eller false värden för logik och beslutsfattande.

  • Matriser — Samlingar med fast storlek av element av samma typ.

  • 2D-matriser — Matriser av matriser; idealiska för att representera rader, rutnät eller tabellliknande data.

  • Const — En variabel deklarerad med const kan inte ändras.

Deklarera och tilldela en variabel#

För att skapa en variabel i C++ måste du deklarera dess typ följt av variabelnamnet och sedan eventuellt tilldela ett värde med hjälp av operatorn =:

int distance = 100;

När man namnger en variabel måste följande regler följas:

  • Namnet får inte innehålla specialtecken (t.ex. ett utropstecken).

  • Namnet får inte börja med en siffra.

  • Namnet får inte innehålla mellanslag.

  • Namnet får inte stå i konflikt med fördefinierade VEXcode-objekt (till exempel Drivetrain).

  • Namnet får inte vara ett C+±reserverat nyckelord (t.ex. int, for, etc.).

  • Variabelnamn är skiftlägeskänsliga (t.ex. är Distance och distance olika variabler).

Local Variables#

Lokala variabler definieras inuti en funktion eller ett kodblock. De är endast tillgängliga inom funktionens eller blockets omfattning och är inte synliga utanför det.

Definiera funktionen (utanför int main())

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

Anropa funktionen inuti int main()

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

  // Begin project code
  show_local();
}

Lokala variabler används ofta för att lagra tillfälliga värden som bara är relevanta inom en specifik funktion eller del av programmet.

Global Variables#

Globala variabler definieras utanför vilken funktion eller vilket block som helst. De kan nås och läsas var som helst i programmet, inklusive inuti funktioner.

Obs! Globala variabler är tillgängliga var som helst i programmet, vilket kan göra dem praktiska för att dela data mellan funktioner. Att i hög grad förlita sig på globala variabler kan dock leda till oavsiktliga biverkningar, eftersom ändringar av variabeln i en del av programmet kan påverka andra delar oförutsägbart. Av denna anledning är lokala variabler generellt att föredra när det är möjligt, eftersom de begränsar en variabels omfattning till den specifika funktion där den är definierad. Detta minskar sannolikheten för konflikter och gör felsökning enklare.

Definiera funktionen (utanför 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();
}

Anropa funktionen inuti 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);
}

I C++ kan globala variabler nås och ändras direkt inifrån funktioner utan några speciella nyckelord. Om du däremot har en lokal variabel med samma namn kan du använda scope-upplösningsoperatorn :: för att komma åt den globala variabeln.

Definiera funktionen (utanför 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();
}

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

Typer av data#

C++ stöder flera typer av data som kan lagras i variabler. Vissa typer kan omtilldelas, medan andra tillåter att enskilda element modifieras. Nedan följer de vanligaste typerna:

Integer#

Ett heltal (int) är ett heltal.

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#

En dubbel är ett decimaltal med hög precision (vanligtvis 64-bitars).

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#

Ett flyttecken lagrar decimaltal. I de flesta VEX-projekt är doubles att föredra framför flyttecken om inte minnesanvändningen är ett problem.

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#

En C-stil sträng (char variable_name[]) är en sekvens av tecken som lagras i en teckenmatris. C-stilsträngar måste vara tillräckligt stora för att lagra texten och en nullterminator.

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#

Ett booleskt (bool) representerar true eller false värden.

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

Booleanska värden kan ändras när som helst i projektet.

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#

Matriser är samlingar med fast storlek av element av samma typ, med början vid index 0. Det är god praxis att känna till matrisens längd och deklarera den vid skapandet.

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#

En 2D-matris används ofta för att representera rutnät, tabeller eller matriser. Varje rad representerar en specifik gruppering av data.

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

Du kan ändra specifika element i en 2D-matris:

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#

En variabel deklarerad med const kan inte ändras efter att den har initialiserats.

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