Athróga#

Réamhrá#

Stórálann athróga sonraí agus ligeann siad duit iad a athúsáid agus a ionramháil ar fud do chláir. Is teanga chlóscríofa go statach í C++, rud a chiallaíonn go gcaithfidh tú cineál athróige a dhearbhú go sainráite nuair a chruthaíonn tú í. Ní féidir an cineál a athrú tar éis a dearbhaithe. Mar shampla:

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

Tá C++ clóscríofa go láidir freisin, rud a chiallaíonn nach féidir leat oibríochtaí a dhéanamh ar chineálacha neamh-chomhoiriúnacha gan tiontú sainráite. Mar shampla:

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

Míníonn an API seo cineálacha athróg coitianta i C++. Cé nach liosta uileghabhálach é, clúdaíonn sé na cineálacha is dóichí a úsáidfidh tú i gcleachtas.

  • Athróga áitiúla — Dearbhaithe laistigh de fheidhm agus úsáidte laistigh den raon feidhme sin amháin; is fearr le haghaidh luachanna sealadacha nó aonraithe.

  • Athróga domhanda — Dearbhaítear lasmuigh d’aon fheidhm iad agus úsáidtear iad ar fud an tionscadail; tá siad go maith chun sonraí a roinnt idir feidhmeanna.

  • Slánuimhir — Uimhreacha iomlána a úsáidtear le haghaidh comhaireamh, achair, nó aon rud gan deachúlacha.

  • Dúbailte — Uimhreacha deachúlacha ardchruinnis le haghaidh ríomhanna matamaiticiúla a éilíonn cruinneas.

  • Snámhphointe — Uimhreacha deachúlacha cruinne caighdeánacha, úsáideach le haghaidh tomhais nó ríomhanna.

  • Teaghrán stíl C — Luachanna téacs, a úsáidtear le haghaidh teachtaireachtaí, lipéid, nó chun aschur inléite a thaispeáint.

  • Booléanach (bool) — true nó false luach le haghaidh loighic agus cinnteoireachta.

  • Eagair — Bailiúcháin eilimintí den chineál céanna de mhéid sheasta.

  • Eagair 2T — Eagair d’eagair; oiriúnach chun sraitheanna, greillí, nó sonraí cosúil le táblaí a léiriú.

  • Const — Ní féidir athróg a dhearbhaítear le const a mhodhnú.

Athróg a Dhearbhú agus a Shannadh#

Chun athróg a chruthú i C++, ní mór duit a cineál a dhearbhú agus ainm na hathróige ina dhiaidh sin, agus ansin luach a shannadh más mian leat ag baint úsáide as an oibreoir =:

int distance = 100;

Agus athróg á hainmniú, ní mór cloí leis na rialacha seo a leanas:

  • Ní féidir carachtair speisialta (m.sh., pointe eascráite) a bheith san ainm.

  • Ní féidir leis an ainm tosú le huimhir.

  • Ní féidir spásanna a úsáid san ainm.

  • Ní féidir leis an ainm coimhlint a dhéanamh le réada VEXcode réamhshainithe (mar shampla, Drivetrain).

  • Ní féidir leis an ainm a bheith ina eochairfhocal atá curtha in áirithe i C++ (m.sh., int, for, srl.).

  • Bíonn ainmneacha athróg íogair ó thaobh cás de (m.sh., is athróga difriúla iad Distance agus distance).

Local Variables#

Sainmhínítear athróga áitiúla laistigh de fheidhm nó de bhloc cóid. Ní féidir rochtain a fháil orthu ach amháin laistigh de raon feidhme na feidhme nó an bhloic sin agus ní féidir iad a fheiceáil lasmuigh de.

Sainmhínigh an fheidhm (lasmuigh de int main())

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

Glaoigh ar an fheidhm taobh istigh 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();
}

Úsáidtear athróga áitiúla go coitianta chun luachanna sealadacha a stóráil nach bhfuil ábhartha ach laistigh de fheidhm nó de chuid den chlár.

Global Variables#

Sainmhínítear athróga domhanda lasmuigh d’aon fheidhm nó bloc. Is féidir rochtain a fháil orthu agus iad a léamh áit ar bith sa chlár, lena n-áirítear taobh istigh de fheidhmeanna.

Nóta: Is féidir rochtain a fháil ar athróga domhanda ó áit ar bith sa chlár, rud a fhágann go bhfuil siad áisiúil chun sonraí a roinnt idir feidhmeanna. Mar sin féin, is féidir le brath go mór ar athróga domhanda fo-iarsmaí neamhbheartaithe a bheith mar thoradh air, toisc go bhféadfadh athruithe ar an athróg i gcuid amháin den chlár dul i bhfeidhm ar chodanna eile go neamh-intuartha. Ar an gcúis seo, is fearr athróga áitiúla go ginearálta nuair is féidir, toisc go gcuireann siad teorainn le raon feidhme athróg don fheidhm shonrach ina bhfuil sí sainmhínithe. Laghdaíonn sé seo an dóchúlacht go dtarlóidh coimhlintí agus déanann sé dífhabhtú níos éasca.

Sainmhínigh an fheidhm (lasmuigh 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();
}

Glaoigh ar an fheidhm taobh istigh 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);
}

I C++, is féidir rochtain dhíreach a fháil ar athróga domhanda agus iad a mhodhnú ó laistigh de fheidhmeanna gan aon eochairfhocail speisialta. Mar sin féin, má tá athróg áitiúil agat leis an ainm céanna, is féidir leat an t-oibreoir réitigh raoin feidhme :: a úsáid chun rochtain a fháil ar an athróg dhomhanda.

Sainmhínigh an fheidhm (lasmuigh 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();
}

Glaoigh ar an fheidhm taobh istigh 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();
}

Cineálacha Sonraí#

Tacaíonn C++ le roinnt cineálacha sonraí is féidir a stóráil in athróga. Is féidir roinnt cineálacha a ath-shannadh, agus ceadaíonn cinn eile eilimintí aonair a mhodhnú. Seo a leanas na cineálacha is coitianta a úsáidtear:

Integer#

Is uimhir iomlán í slánuimhir (int).

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#

Is uimhir dheachúil í dúbailte a bhfuil cruinneas ard aici (64-giotán de ghnáth).

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#

Stórálann snámhphointe uimhreacha deachúlacha. I bhformhór na dtionscadal VEX, is fearr dúbailtí ná snámhphointí mura bhfuil úsáid cuimhne ina ábhar imní.

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#

Is sraith carachtar atá stóráilte in eagar carachtar é téacs stíl C (char variable_name[]). Caithfidh teaghráin stíl C a bheith mór go leor chun an téacs agus críochnóir nialasach a stóráil.

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#

Seasann Booléanach (bool) do true nó 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...");
  }
}

Is féidir Booleans a athrú ag aon phointe sa tionscadal.

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#

Is bailiúcháin de mhéid seasta d’eilimintí den chineál céanna iad eagarraí, ag tosú ag innéacs 0. Is dea-chleachtas é fad an eagair a bheith ar eolas agat agus é a dhearbhú tráth a chruthaithe.

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#

Úsáidtear eagar 2T go coitianta chun greillí, táblaí nó maitrísí a léiriú. Seasann gach ró do ghrúpáil shonrach sonraí.

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

Is féidir leat eilimintí sonracha a mhodhnú laistigh d’eagar 2T:

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#

Ní féidir athróg a dhearbhaítear le const a mhodhnú tar éis í a thosú.

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