Funktionen#

Einführung #

Funktionen sind ein grundlegender Bestandteil der C+±Programmierung. Sie fassen Codeabschnitte in wiederverwendbare, effiziente Codeblöcke zusammen, die jeweils eine bestimmte Aufgabe erfüllen. Funktionen können innerhalb eines Programms mehrfach aufgerufen werden, was die Codeorganisation vereinfacht und Code-Wiederholungen vermeidet. Zudem erleichtern Funktionen das Debuggen von Code.

Diese Seite behandelt die Grundlagen der Verwendung von Funktionen in C++, einschließlich:

Funktionsstruktur und Syntax — Wie Funktionen in C++ geschrieben werden, einschließlich Rückgabetypen, Namen und Parameter.
Funktionsprototypen — Was Prototypfunktionen sind und warum sie verwendet werden.
Funktionen definieren und aufrufen — Wie man Funktionen erstellt und sie aus dem Programm aufruft.
Rückgabewerte — Wie Funktionen Daten an den Aufrufer zurücksenden können.
Übergabe per Referenz — Wie Funktionen Variablen außerhalb ihres eigenen Gültigkeitsbereichs verändern können.
Callback-Funktionen — Wie Funktionen an andere Funktionen übergeben und automatisch als Reaktion auf Ereignisse aufgerufen werden können.
Funktionen mit Standardargumenten — Wie Parametern Standardwerte zugewiesen werden können, wenn kein Argument angegeben wird.

Funktionsstruktur und Syntax #

In C++ müssen Funktionen mit ihrem Rückgabetyp, Namen und Parametern deklariert werden. Die grundlegende Syntax lautet:

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

Funktionsteile	Beschreibung
`return_type`	Der Datentyp, den die Funktion zurückgibt. Einige gängige Optionen sind: `void` — Gibt nichts zurück `int` — Gibt einen ganzzahligen Wert zurück `double` — Gibt eine Gleitkommazahl zurück `bool` — Gibt `true` oder `false` `char` — Gibt ein einzelnes Zeichen zurück `const char*` — Gibt eine Textzeichenkette zurück benutzerdefinierte Typen — Gibt ein `struct`
`function_name`	Der Name der Funktion.
`parameters`	Optional. Eine durch Kommas getrennte Liste typisierter Parameter im Format `type name`, wobei `type` den Datentyp des Parameters und `name` den Bezeichner für den Zugriff auf diesen Wert innerhalb der Funktion angibt. Parameter erhalten Eingabewerte beim Funktionsaufruf.
`result`	Optional. The value returned by the function. If the function’s `return_type` is not `void`, this value must be provided and its type must exactly match the specified `return_type`.

Hinweis: Eine Funktion muss immer vor ihrem Aufruf deklariert werden, oder Sie müssen einen Funktionsprototyp angeben.

Funktionsprototypen #

In C++ wird der Code von oben nach unten gelesen. Das bedeutet, dass eine Funktion dem Compiler bekannt sein muss, bevor sie aufgerufen werden kann.

Ein Funktionsprototyp ermöglicht es Ihnen, eine Funktion zu verwenden, bevor Sie ihren vollständigen Code schreiben. Dadurch können Sie main() nahe am Anfang Ihres Programms platzieren, während Sie Funktionsdefinitionen später einfügen, wo sie übersichtlicher und besser lesbar sind.

Ohne einen Prototyp müsste man jede Funktion oberhalb main()Projekten mit zunehmender Größe erschweren kann.

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

int main() {
  greeting();
}

// Write the function's body after
void greeting() {
  Brain.Screen.print("Hello!");
}

Funktionen definieren und aufrufen #

Functions with No Parameters #

Wenn eine Funktion keine Eingabe benötigt, kann sie ohne Parameter definiert werden. Verwenden Sie void als Rückgabetyp, wenn die Funktion keinen Wert zurückgibt.

// 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 #

Sie können Funktionen auch Parameter hinzufügen, mit denen Sie der Funktion Informationen übergeben können.

Hinweis: Text kann mittels C-Strings (const char*) oder C+±Strings (std::string ) übergeben werden.

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

Rückgabewerte #

Funktionen können Daten mithilfe des Schlüsselworts return an den Aufrufer zurücksenden. Dadurch können Sie die Ausgabe erfassen und in Ihrem Projekt verwenden.

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

Übergabe durch Bezugnahme #

By default, C++ passes function parameters by value, meaning the function receives a copy of the original variable. Changes made inside the function do not affect the original value.

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

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

Um einer Funktion die Möglichkeit zu geben, die ursprüngliche Variable zu verändern, können Parameter per Referenz mit Hilfe des Symbols & übergeben werden.

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

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

Passing by reference allows functions to update variables defined outside the function without returning a value.

Callback-Funktionen #

Eine Callback-Funktion ist eine Funktion, die an eine andere Funktion übergeben wird und automatisch aufgerufen wird, wenn ein bestimmtes Ereignis eintritt.

Callbacks werden häufig für Ereignisse wie Tastendrücke oder Sensoraktualisierungen verwendet.

Anstatt die Funktion selbst aufzurufen, ruft das Projekt sie für Sie auf, wenn das Ereignis eintritt.

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

// Call onPressed whenever the screen is pressed
int main() {
  vexcodeInit();
  Brain.Screen.pressed(onPressed);
}

Callback Signatures #

Jede Callback-Funktion muss einer bestimmten Signatur folgen, die Folgendes definiert:

Der Rückgabetyp
Die Anzahl der Parameter
Die Parametertypen

Die erforderliche Signatur wird von der API festgelegt. Die Callback-Funktion muss exakt mit dieser Signatur übereinstimmen.

// 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);

Die Parameternamen sind beschreibend und können variieren, aber der Rückgabetyp, die Parameterreihenfolge und die Parametertypen müssen exakt übereinstimmen.

Funktionen mit Standardargumenten #

Funktionen können Standardwerte für einen oder mehrere Parameter definieren. Ein Standardargument wird verwendet, wenn beim Funktionsaufruf kein Wert für den jeweiligen Parameter angegeben wird.

Regeln für Standardargumente:

Standardargumente müssen die letzten Parameter in der Funktionsdefinition sein.
Sobald ein Parameter einen Standardwert hat, müssen alle nachfolgenden Parameter ebenfalls Standardwerte haben.
Wenn eine Funktion in ihrem Prototyp Standardargumente angibt, dürfen diese Standardwerte in der Funktionsdefinition nicht erneut angegeben werden.

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