Kintamieji#

Įvadas#

Kintamieji saugo duomenis ir leidžia juos pakartotinai naudoti bei manipuliuoti visoje programoje. C++ yra statiškai tipizuota kalba, o tai reiškia, kad kurdami kintamąjį turite aiškiai deklaruoti jo tipą. Tipo negalima pakeisti po deklaravimo. Pavyzdžiui:

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++ taip pat yra griežtai tipizuota, o tai reiškia, kad negalima atlikti operacijų su nesuderinamais tipais be aiškaus konvertavimo. Pavyzdžiui:

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

Šioje API paaiškinami dažniausiai pasitaikantys kintamųjų tipai C++ kalboje. Nors tai nėra išsamus sąrašas, jame aprašomi tipai, kuriuos greičiausiai naudosite praktikoje.

  • Vietiniai kintamieji – deklaruojami funkcijos viduje ir naudojami tik toje srityje; geriausiai tinka laikinoms arba izoliuotoms reikšmėms.

  • Globalieji kintamieji – deklaruojami už bet kurios funkcijos ribų ir naudojami visame projekte; tinka duomenims bendrinti tarp funkcijų.

  • Sveikasis skaičius — Sveikieji skaičiai, naudojami skaičiavimui, atstumams ar bet kam be dešimtainių trupmenų.

  • Double — Didelio tikslumo dešimtainiai skaičiai matematiniams skaičiavimams, kuriems reikalingas tikslumas.

  • Float — standartinio tikslumo dešimtainiai skaičiai, naudingi matavimams ar skaičiavimams.

  • C stiliaus eilutė – tekstinės reikšmės, naudojamos pranešimams, žymoms arba skaitomos išvesties rodymui.

  • Boolean(bool) — true arba false reikšmės logikai ir sprendimų priėmimui.

  • Masyvai — Fiksuoto dydžio to paties tipo elementų rinkiniai.

  • 2D masyvai – masyvų masyvai; idealiai tinka eilutėms, tinkleliams arba lentelių tipo duomenims pavaizduoti.

  • Konstanta — Kintamasis, deklaruotas su const negali būti modifikuotas.

Kintamojo deklaravimas ir priskyrimas#

Norėdami sukurti kintamąjį C++ kalboje, turite nurodyti jo tipą, po kurio nurodomas kintamojo pavadinimas, o tada pasirinktinai priskirti reikšmę naudodami operatorių =:

int distance = 100;

Pavadinant kintamąjį, reikia laikytis šių taisyklių:

  • Pavadinime negali būti specialiųjų simbolių (pvz., šauktuko).

  • Pavadinimas negali prasidėti skaičiumi.

  • Pavadinime negali būti tarpų.

  • Pavadinimas negali konfliktuoti su iš anksto apibrėžtais VEXcode objektais (pavyzdžiui, Drivetrain).

  • Pavadinimas negali būti rezervuotas C++ raktinis žodis (pvz., int, forir t. t.).

  • Kintamųjų pavadinimai yra didžiųjų ir mažųjų raidžių jautrios (pvz., Distance ir distance yra skirtingi kintamieji).

Local Variables#

Vietiniai kintamieji yra apibrėžti funkcijos arba kodo bloko viduje. Jie pasiekiami tik tos funkcijos arba bloko ribose ir nėra matomi už jų ribų.

Apibrėžkite funkciją (už int main())

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

Iškvieskite funkciją int main()

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

  // Begin project code
  show_local();
}

Vietiniai kintamieji dažniausiai naudojami laikinoms reikšmėms, kurios yra svarbios tik tam tikroje funkcijoje arba programos dalyje, saugoti.

Global Variables#

Globalūs kintamieji apibrėžiami už bet kurios funkcijos ar bloko ribų. Juos galima pasiekti ir skaityti bet kur programoje, įskaitant funkcijų viduje.

Pastaba: globalūs kintamieji pasiekiami iš bet kurios programos vietos, todėl juos patogu naudoti bendrinant duomenis tarp funkcijų. Tačiau per didelis pasikliovimas globaliais kintamaisiais gali sukelti nenumatytų šalutinių poveikių, nes kintamojo pakeitimai vienoje programos dalyje gali nenuspėjamai paveikti kitas dalis. Dėl šios priežasties, kai įmanoma, paprastai pirmenybė teikiama lokaliems kintamiesiems, nes jie apriboja kintamojo taikymo sritį iki konkrečios funkcijos, kurioje jis apibrėžtas. Tai sumažina konfliktų tikimybę ir palengvina derinimą.

Apibrėžkite funkciją (už 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();
}

Iškvieskite funkciją 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++ kalboje prie globaliųjų kintamųjų galima tiesiogiai prisijungti ir juos modifikuoti funkcijų viduje be jokių specialių raktinių žodžių. Tačiau jei turite lokalų kintamąjį tuo pačiu pavadinimu, galite naudoti apimties skiriamosios gebos operatorių :: kad pasiektumėte globalųjį kintamąjį.

Apibrėžkite funkciją (už 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();
}

Iškvieskite funkciją 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();
}

Duomenų tipai#

C++ palaiko kelių tipų duomenis, kuriuos galima saugoti kintamuosiuose. Kai kuriuos tipus galima priskirti iš naujo, o kiti leidžia modifikuoti atskirus elementus. Žemiau pateikiami dažniausiai naudojami tipai:

Integer#

Sveikasis skaičius (int) yra sveikasis skaičius.

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 yra didelio tikslumo dešimtainis skaičius (paprastai 64 bitų).

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 reikšmė saugo dešimtainius skaičius. Daugumoje VEX projektų doubles yra pageidaujama vietoj float, nebent svarbus atminties naudojimas.

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 stiliaus eilutė (char variable_name[]) yra simbolių seka, saugoma simbolių masyve. C stiliaus eilutės turi būti pakankamai ilgos, kad joje tilptų tekstas ir nulinė nutraukančioji reikšmė.

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ūlio reikšmė (bool) reiškia true arba 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...");
  }
}

Būlio reikšmes galima keisti bet kuriame projekto etape.

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#

Masyvai yra fiksuoto dydžio to paties tipo elementų rinkiniai, prasidedantys nuo indekso 0. Patartina žinoti masyvo ilgį ir jį deklaruoti kūrimo metu.

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 masyvas dažniausiai naudojamas tinkleliams, lentelėms arba matricoms pavaizduoti. Kiekviena eilutė žymi konkrečią duomenų grupę.

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

Galite modifikuoti konkrečius elementus 2D masyve:

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#

Kintamojo, deklaruoto su const negalima modifikuoti po jo inicijavimo.

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