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.

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

int main() {
  greeting();
}

// Write the function's body after
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.

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    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).

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    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.

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    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.

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

int main() {
  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.

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

int main() {
  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.

void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

// Call onPressed whenever the screen is pressed
int main() {
  vexcodeInit();
  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.

// 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 (V5) and
    // use default value for repeatCount (1)
    greeting("V5");

    Brain.Screen.newLine();

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