Funkciók#

Bevezetés#

A függvények a C++ programozás alapvető elemei, amelyek a kódrészleteket újrafelhasználható, hatékony kódrészletekbe csomagolják, és egy adott feladat végrehajtására szolgálnak. A függvények többször is meghívhatók egy programon belül, ami megkönnyíti a kód rendszerezését és segít elkerülni az ismétlődő kódot. A függvények a kód hibakeresését is megkönnyítik.

Ez az oldal a C++ függvények használatának alapjait tárgyalja, beleértve a következőket:

Függvénystruktúra és szintaxis#

A C+±ban a függvényeket a visszatérési típusukkal, nevükkel és paramétereikkel kell deklarálni. Az alapvető szintaxis a következő:

return_type function_name(parameters) {
  // Code to execute when the function is called
  return result;  // Optional, used to return a value
}

Funkció részei

Leírás

return_type

A függvény által visszaadott adattípus, néhány gyakori beállítási lehetőség:

  • void — Semmit sem ad vissza
  • int — Egész értéket ad vissza
  • double — Lebegőpontos számot ad vissza
  • bool — true vagy false
  • char — Egyetlen karaktert ad vissza
  • const char* — Szöveges karakterláncot ad vissza
  • felhasználó által definiált típusok — struct vagy osztályobjektumot ad vissza

function_name

A függvény neve.

parameters

Opcionális. Tipikus paraméterek vesszővel elválasztott listája, type nameformátumban írva, ahol type a paraméter adattípusát, name pedig az azonosítót jelöli, amely a függvényen belül az adott érték eléréséhez használható. A paraméterek bemeneti értékeket kapnak a függvény meghívásakor.

result

Opcionális. A függvény által visszaadott érték. Ha a függvény return_type típusa nem void ,ezt az értéket meg kell adni, és a típusának pontosan meg kell egyeznie a megadott return_type .

Megjegyzés: Egy függvényt *mindig deklarálni kell a meghívása előtt, vagy meg kell adni egy függvény prototípust.

Funkcióprototípusok#

A C+±ban a kódot felülről lefelé olvassuk. Ez azt jelenti, hogy a függvényt ismernie kell a fordítónak, mielőtt meghívható lenne.

Egy függvényprototípus lehetővé teszi egy függvény felhasználását a teljes kód megírása előtt. Ez lehetővé teszi, hogy main() függvényeket a program tetején tartsuk, miközben a függvénydefiníciókat későbbre, könnyebben rendszerezhetővé és olvashatóvá tegyük.

Prototípus nélkül minden main()feletti függvényt definiálni kellene, ami megnehezítheti a projektek követését a növekedésük során.

Definiáljuk a függvény prototípusát ( int main())

// The function's prototype
void greeting();

Hívjuk meg a függvényt int main()

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

  greeting();
}

Írd le a függvény törzsét a következő után:

void greeting() {
  Brain.Screen.print("Hello!");
}

Függvények definiálása és meghívása#

Functions with No Parameters#

Ha egy függvény nem igényel bemenetet, paraméterek nélkül is definiálhatod. Használj void visszatérési típust, ha a függvény nem ad vissza értéket.

Definiáld a függvényt ( int main())

// Define a function to display a message
void greeting() {
    Brain.Screen.print("Hello!");
}

Hívjuk meg a függvényt int main()

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

  // Call the function to display the message
  greeting();
}

Functions with Parameters#

Paramétereket is hozzáadhatsz a függvényekhez, amelyek lehetővé teszik, hogy információkat adj meg a függvény számára.

Megjegyzés: A szöveg átadható C stílusú karakterláncokkal (const char*) vagy C++ stílusú karakterláncokkal (std::string).

Definiáld a függvényt ( int main())

// Define a function with a parameter
void namedGreeting(const char* name) {
    Brain.Screen.print("Hello, %s!", name);
}

Hívjuk meg a függvényt egy int main()

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

  // Call the function to display the message
  namedGreeting("Stranger");
}

Visszatérési értékek#

A függvények a return kulcsszó használatával küldhetnek adatokat a hívónak. Ez lehetővé teszi a kimenet rögzítését és felhasználását a projektben.

Definiáld a függvényt ( int main())

// Define a function that multiplies numbers by 2
int timesTwo(int number) {
    return number * 2;
}

Hívjuk meg a függvényt egy int main()

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

  // Display the return value
  Brain.Screen.print("%d", timesTwo(2));
}

Áthaladás hivatkozással#

Alapértelmezés szerint a C++ érték szerint adja át a függvényparamétereket, ami azt jelenti, hogy a függvény az eredeti változó másolatát kapja meg. A függvényen belüli változtatások nem befolyásolják az eredeti értéket.

Definiáld a függvényt ( int main())

// Add 1 to the number
void addOne(int number) {
  number++;
}

Hívjuk meg a függvényt egy int main()

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

  int value = 5;
  addOne(value);
  // "value" will still be 5
}

Ahhoz, hogy egy függvény módosíthassa az eredeti változót, a paramétereket hivatkozással adhatjuk át az & szimbólum használatával.

Definiáld a függvényt ( int main())

// Add 1 to the number
void addOne(int& number) {
  number++;
}

Hívjuk meg a függvényt egy int main()

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

  int value = 5;
  addOne(value);
  // "value" will now be 6
}

A hivatkozáson keresztüli átadás lehetővé teszi a függvények számára, hogy a függvényen kívül definiált változók értéket adjanak vissza.

Visszahívó függvények#

A visszahívó függvény egy olyan függvény, amelyet átadunk egy másik függvénynek, és automatikusan meghívunk, amikor egy adott esemény bekövetkezik.

A visszahívásokat gyakran használják olyan eseményekhez, mint a gombnyomások vagy az érzékelők frissítései.

Ahelyett, hogy te magad hívnád meg a függvényt, a projekt hívja meg helyetted, amikor az esemény bekövetkezik.

Definiáljuk a visszahívó függvényt ( int main())

// Create a callback function
void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

Regisztrálja a visszahívást a int main() függvényen belül.

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

  // Call onPressed whenever the screen is pressed
  Brain.Screen.pressed(onPressed);
}

Callback Signatures#

Minden visszahívó függvénynek egy adott aláírást kell követnie, amely meghatározza:

  • A visszatérési típus

  • A paraméterek száma

  • A paramétertípusok

A szükséges aláírást az API határozza meg. A visszahívó függvénynek pontosan meg kell egyeznie ezzel az aláírással.

// This callback function cannot include any parameters
void callback(void);


// This callback function includes four parameters
void callback(axisType axis, double x, double y, double z);

A paraméternevek leíró jellegűek és változhatnak, de a visszatérési típusnak, a paraméterek sorrendjének és típusának pontosan meg kell egyeznie.

Alapértelmezett argumentumokkal rendelkező függvények#

A függvények egy vagy több paraméterhez alapértelmezett értékeket definiálhatnak. Az alapértelmezett argumentumot akkor használjuk, ha a függvény meghívásakor az adott paraméterhez nincs megadva érték.

Alapértelmezett argumentumok szabályai:

  • Az alapértelmezett argumentumoknak a függvénydefinícióban az utolsó paramétereknek kell lenniük.

  • Ha egy paraméter alapértelmezett értéket kapott, akkor az azt követő összes paraméternek is alapértelmezett értékkel kell rendelkeznie.

  • Ha egy függvény alapértelmezett argumentumokat ad meg a prototype paraméterben, akkor ezeket az alapértelmezett értékeket nem szabad újra megadni a függvénydefinícióban.

Definiáld a függvényt ( int main())

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

Hívjuk meg a függvényt int main()

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

  // Say what name to greet (EXP) and
  // use default value for repeatCount (1)
  greeting("EXP");

  Brain.Screen.newLine();

  // Overrides the default value to 3
  greeting("EXP", 3);
}


// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

int main() {
    vexcodeInit();

    // Say what name to greet (EXP) and
    // use default value for repeatCount (1)
    greeting("EXP");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("EXP", 3);
}
On this page