Parameterübergabe per Zeiger

In C++ werden beim Übergeben von Parametern an Funktionen normalerweise Call by Value (Wertübergabe) oder Call by Reference (Referenzübergabe) verwendet. Manchmal muss eine Funktion jedoch direkt mit einer Speicheradresse arbeiten — in diesem Fall kommt die Pointer-Übergabe ins Spiel. Diese Methode ermöglicht es, Variablen direkt im Speicher zu ändern, ohne sie zu kopieren.

1. Unterschied zwischen Wert- und Pointer-Übergabe

Wenn Parameter per Wert übergeben werden, wird eine Kopie der Originalvariablen erstellt. Änderungen innerhalb der Funktion beeinflussen die Originalvariable nicht. Bei der Übergabe per Pointer greift die Funktion hingegen direkt auf den ursprünglichen Speicher zu.

#include <iostream>
using namespace std;

void WertAendern(int x) {
    x = 20;
}

void MitPointerAendern(int *p) {
    *p = 20;
}

int main() {
    int zahl = 10;

    WertAendern(zahl);
    cout << "Nach Wertübergabe: " << zahl << endl; // 10

    MitPointerAendern(&zahl);
    cout << "Nach Pointer-Übergabe: " << zahl << endl; // 20
}

Fazit: Durch die Pointer-Übergabe kann der Wert einer Variablen direkt über ihre Adresse geändert werden.

2. Definition von Pointer-Parametern

Wenn eine Funktion einen Pointer-Parameter verwendet, wird der Parametertyp mit einem * gekennzeichnet. Beim Aufruf der Funktion wird die Adresse der Variablen mit & übergeben.

void Aendere(int *ptr) {
    *ptr = *ptr + 5;
}

Innerhalb der Funktion ändert der Ausdruck *ptr den tatsächlichen Wert der Variablen, auf die gezeigt wird. Diese Methode spart Speicher und verbessert häufig die Performance.

3. Mehrere Pointer-Parameter

Es können mehrere Adressen gleichzeitig an eine Funktion übergeben werden. Diese Technik ist besonders nützlich für arithmetische Operationen oder Tauschfunktionen (swap).

#include <iostream>
using namespace std;

void WerteTauschen(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    WerteTauschen(&x, &y);
    cout << "x: " << x << ", y: " << y << endl; // x:10, y:5
}

In diesem Beispiel greifen Pointer-Parameter direkt auf die Speicheradressen der Variablen zu. Die Werte außerhalb der Funktion werden erfolgreich geändert.

4. const Pointer-Parameter

Wenn eine Funktion den übergebenen Wert nicht verändern soll, kann der Pointer-Parameter mit const deklariert werden.

void Ausgabe(const int *p) {
    cout << "Wert: " << *p << endl;
}

int main() {
    int zahl = 42;
    Ausgabe(&zahl);
}

In diesem Fall kann die Funktion nur lesen, aber nicht schreiben. Das erhöht die Sicherheit des Codes und verhindert unbeabsichtigte Änderungen.

5. Pointer und Arrays (Array-Parameter)

In C++ verhalten sich Arrays wie Pointer. Wenn Arrays an Funktionen übergeben werden, wird die Adresse des ersten Elements übergeben.

void Ausgabe(int *array, int laenge) {
    for (int i = 0; i < laenge; i++) {
        cout << array[i] << " ";
    }
    cout << endl;
}

int main() {
    int zahlen[] = {10, 20, 30, 40, 50};
    Ausgabe(zahlen, 5);
}

Innerhalb der Funktion kann man mit array[i] oder *(array + i) auf die Elemente zugreifen. Der Arrayname repräsentiert die Adresse des ersten Elements.

6. Pointer mit dynamischem Speicher

Pointer-Parameter können auch mit Daten verwendet werden, die dynamisch im Heap erzeugt werden.

#include <iostream>
using namespace std;

void Fuellen(int *p, int laenge) {
    for (int i = 0; i < laenge; i++)
        p[i] = (i + 1) * 10;
}

int main() {
    int *array = new int[5]; // Dynamisches Array im Heap
    Fuellen(array, 5);

    for (int i = 0; i < 5; i++)
        cout << array[i] << " ";

    delete[] array; // Speicher freigeben
}

In diesem Beispiel wurden die Elemente eines Arrays, das im Heap erstellt wurde, über einen Pointer-Parameter gefüllt. Nach dem Funktionsaufruf muss der Speicher mit delete[] freigegeben werden.

7. Pointer auf Pointer (Doppelpointer)

Es ist möglich, die Adresse eines Pointers selbst zu speichern. In diesem Fall wird ein Pointer auf Pointer verwendet. Dies ist besonders nützlich, wenn eine Funktion den Pointer selbst ändern muss.

void PointerAendern(int **p) {
    static int wert = 99;
    *p = &wert; // ändert die Adresse, auf die der Pointer zeigt
}

int main() {
    int x = 10;
    int *ptr = &x;

    PointerAendern(&ptr);
    cout << "Neuer Wert: " << *ptr << endl; // 99
}

Diese Methode erlaubt es der Funktion, nicht nur die Daten, sondern auch den Pointer selbst zu ändern. Sie wird häufig in Funktionen verwendet, die dynamischen Speicher verwalten.

8. Moderne C++-Alternative: Referenzen und Smart Pointer

Mit modernem C++ (C++11 und neuer) werden klassische Pointer-Parameter oft durch Referenzen oder Smart Pointer ersetzt:

• int& → sicher, kann nicht null sein, keine manuelle Speicherverwaltung.
• std::unique_ptr → besitzt exklusiven Besitz eines Objekts.
• std::shared_ptr → ermöglicht geteilten Besitz eines Objekts.

In der Systemprogrammierung, eingebetteten Systemen oder bei Performance-kritischen Anwendungen werden klassische Pointer-Parameter jedoch weiterhin häufig verwendet.

9. TL;DR

Ähnliche Artikel