Mainīgie lielumi#

Ievads#

Mainīgie glabā datus un ļauj tos atkārtoti izmantot un manipulēt visā programmā. C++ ir statiski tipizēta valoda, kas nozīmē, ka mainīgā tips ir skaidri jādeklarē, to izveidojot. Pēc deklarēšanas tipu nevar mainīt. Piemēram:

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++ ir arī stingri tipizēts, kas nozīmē, ka nevar veikt darbības ar nesaderīgiem tipiem bez skaidras konvertēšanas. Piemēram:

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

Šis API izskaidro biežāk sastopamos mainīgo tipus valodā C++. Lai gan tas nav pilnīgs saraksts, tas aptver tipus, kurus jūs, visticamāk, izmantosiet praksē.

  • Lokālie mainīgie — Deklarēti funkcijas iekšpusē un tiek izmantoti tikai šajā darbības jomā; vislabāk piemēroti pagaidu vai izolētām vērtībām.

  • Globālie mainīgie — Deklarēti ārpus jebkuras funkcijas un izmantoti visā projektā; labi piemēroti datu apmaiņai starp funkcijām.

  • Integer — Veseli skaitļi, ko izmanto skaitīšanai, attālumiem vai jebkam citam bez decimāldaļām.

  • Double — Augstas precizitātes decimālskaitļi matemātiskiem aprēķiniem, kuriem nepieciešama precizitāte.

  • Peldošais skaitlis — standarta precizitātes decimālskaitļi, noderīgi mērījumiem vai aprēķiniem.

  • C stila virkne — teksta vērtības, ko izmanto ziņojumiem, etiķetēm vai lasāmas izvades attēlošanai.

  • Boolean(bool) — true vai false vērtības loģikai un lēmumu pieņemšanai.

  • Masīvi — Fiksēta izmēra viena tipa elementu kolekcijas.

  • 2D masīvi — Masīvu masīvi; ideāli piemēroti rindu, režģu vai tabulas veida datu attēlošanai.

  • Konst — Mainīgo, kas deklarēts ar const nevar modificēt.

Mainīgā deklarēšana un piešķiršana#

Lai izveidotu mainīgo C++ valodā, ir jādeklarē tā tips, kam seko mainīgā nosaukums un pēc izvēles jāpiešķir vērtība, izmantojot operatoru =:

int distance = 100;

Nosaucot mainīgo, jāievēro šādi noteikumi:

  • Nosaukumā nedrīkst būt speciālās rakstzīmes (piemēram, izsaukuma zīme).

  • Nosaukums nevar sākties ar ciparu.

  • Nosaukumā nedrīkst izmantot atstarpes.

  • Nosaukums nedrīkst konfliktēt ar iepriekš definētiem VEXcode objektiem (piemēram, Drivetrain).

  • Nosaukums nevar būt C++ rezervēts atslēgvārds (piemēram, int, forutt.).

  • Mainīgo nosaukumi ir reģistrjutīgi (piemēram, Distance un distance ir dažādi mainīgie).

Local Variables#

Lokālie mainīgie tiek definēti funkcijas vai koda bloka iekšpusē. Tie ir pieejami tikai šīs funkcijas vai bloka ietvaros un nav redzami ārpus tā.

Definējiet funkciju (ārpus int main())

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

Izsauciet funkciju int main()

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

  // Begin project code
  show_local();
}

Lokālie mainīgie parasti tiek izmantoti, lai saglabātu pagaidu vērtības, kas ir būtiskas tikai konkrētai funkcijai vai programmas daļai.

Global Variables#

Globālie mainīgie tiek definēti ārpus jebkuras funkcijas vai bloka. Tiem var piekļūt un tos var nolasīt jebkur programmā, tostarp funkciju iekšpusē.

Piezīme: Globālie mainīgie ir pieejami no jebkuras vietas programmā, kas var atvieglot datu koplietošanu starp funkcijām. Tomēr liela paļaušanās uz globālajiem mainīgajiem var izraisīt neparedzētas blakusparādības, jo izmaiņas mainīgajā vienā programmas daļā var neparedzami ietekmēt citas daļas. Šī iemesla dēļ, ja iespējams, parasti priekšroka tiek dota lokālajiem mainīgajiem, jo tie ierobežo mainīgā darbības jomu līdz konkrētajai funkcijai, kurā tas ir definēts. Tas samazina konfliktu iespējamību un atvieglo atkļūdošanu.

Definējiet funkciju (ārpus 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();
}

Izsauciet funkciju 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);
}

C++ valodā globālajiem mainīgajiem var tieši piekļūt un tos modificēt no funkciju iekšienes bez īpašiem atslēgvārdiem. Tomēr, ja jums ir lokālais mainīgais ar tādu pašu nosaukumu, varat izmantot darbības jomas izšķirtspējas operatoru :: lai piekļūtu globālajam mainīgajam.

Definējiet funkciju (ārpus 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();
}

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

Datu veidi#

C++ atbalsta vairākus datu tipus, kurus var glabāt mainīgajos. Dažus tipus var atkārtoti piešķirt, bet citi ļauj modificēt atsevišķus elementus. Tālāk ir norādīti visbiežāk izmantotie tipi:

Integer#

Vesels skaitlis (int) ir vesels skaitlis.

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 ir decimālzīmes skaitlis ar augstu precizitāti (parasti 64 bitu).

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#

Plodiņskaitlis saglabā decimālskaitļus. Vairumā VEX projektu doubles ir priekšroka salīdzinājumā ar peldiņskaitļiem, ja vien atmiņas izmantošana nav problēma.

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#

C stila virkne (char variable_name[]) ir rakstzīmju secība, kas tiek glabāta rakstzīmju masīvā. C stila virknēm ir jābūt pietiekami garām, lai tajās varētu saglabāt tekstu un null terminatoru.

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#

Būla vērtība (bool) apzīmē true vai false vērtības.

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

Būla vērtības var mainīt jebkurā projekta brīdī.

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#

Masīvi ir fiksēta izmēra viena tipa elementu kolekcijas, sākot ar indeksu 0. Ieteicams zināt masīva garumu un deklarēt to izveides laikā.

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#

2D masīvs parasti tiek izmantots, lai attēlotu režģus, tabulas vai matricas. Katra rinda attēlo noteiktu datu grupu.

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

Jūs varat modificēt noteiktus elementus 2D masīvā:

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#

Mainīgo, kas deklarēts ar const pēc inicializācijas nevar mainīt.

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