Void-Datentyp

Sie müssen immer den Typ angeben, da es sich um eine statisch typisierte Sprache handelt. Der Compiler muss den genauen Typ jeder Variablen kennen, um die richtige Menge an Speicher zuzuweisen und die Typensicherheit zu gewährleisten. Er muss auch die Typen der Rückgabewerte und Parameter von Funktionen kennen.

Hinweis

Eine statisch typisierte Sprache ist eine, bei der der Datentyp einer Variablen explizit deklariert und vom Compiler erzwungen wird.

main


              12345678910
            
#include <iostream>

// Let's consider at a simple example.
// Imagine you need to create a function that logges something in console
// What type should it return?
___ log(std::string message)
{
    std::cout << message;
    return ___;
}

In diesem Fall benötigen wir keinen spezifischen Rückgabetyp, es könnte int, double, float oder bool sein. Für dieses Szenario spielt der genaue Typ keine Rolle. Tatsächlich, was ist, wenn wir überhaupt nichts zurückgeben müssen?

Void als Rückgabetyp einer Funktion

Es gibt oft Funktionen, die scheinbar nichts zurückgeben müssen, wie:

main


              12345678
            
// Outputting infromation in console
___ log(std::string message) { std:: cout << message; }

// Updating values for variables
___ update(int& variable, int new_value) { variable = new_value; }

// Calling other function
___ closeFile(std::fstream& file) { file.close(); }

In diesem Fall können wir den void-Datentyp verwenden. Der void-Datentyp in der Programmierung steht für das Fehlen eines Wertes oder Typs. Er kann auf viele verschiedene Arten verwendet werden, aber bei Funktionen wird er normalerweise verwendet, um anzuzeigen, dass eine Funktion keinen Wert zurückgibt.

main


              123456789101112
            
#include <iostream>

void log(std::string message)
{
    std::cout << message;
    return;
}

int main()
{
    log("This is a void function!");
}

Hinweis

Wir haben ein return-Schlüsselwort verwendet, aber tatsächlich keinen Wert übergeben. Das return-Schlüsselwort könnte in den void-Funktionen auch weggelassen werden. Versuchen Sie, es im Beispiel zu entfernen.

Void als Zeiger

Void-Zeiger (void*) sind Zeiger, die keinem bestimmten Datentyp zugeordnet sind. Sie können auf jeden Objekttyp zeigen, aber Sie müssen sie in den entsprechenden Typ umwandeln, bevor Sie sie verwenden. Sie sind wirklich nützlich, aber manchmal schwer zu verstehen.

main


              1234567891011121314
            
#include <iostream>
int main()
{
    int num = 10;
    // Here we are creating a void pointer
    // Now it can point to any variable of any data type
    // You can try changing the type of `num` from `int` to `float`
	void* ptr = &num;

    // To use this pointer, we need to cast it to the appropriate type
    //                        VVV
    int* intPtr = static_cast<int*>(ptr);
    std::cout << *intPtr << std::endl;  // Output: 10
}

In diesem Beispiel ist ptr ein Void-Pointer, der auf eine Ganzzahl (num) zeigt. Wir casten dann num zu einem int*-Pointer, um den Wert von num zuzugreifen und auszugeben.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 4. Kapitel 3