Zeiger nicht verstanden



  • Hallo,
    ich muss euch wieder etwas fragen:

    Zeiger:

    int* p : bedeutet:

    1. p ist ein Zeiger auf int (wieso soll ein zeiger auf dem Typ int zeigen??)
    2. p zeigt irgendwo hin. (verstehe ich)

    int* foo ( int value){ ... } : bedeutet:

    1. die funktion ist ein Zeiger auf dem Typ int? wie die 1. frage

    Kann mir das einer erklären?



  • Jaja, diese sch...önen Zeiger, also, int* kann die Adresse einer int-Variablen speichern, zeigt also darauf. Die Funktion ist dann kein Zeiger auf int, sie gibt nur einen Zeiger (also die Adresse) eines ints zurück. Um letzendlich aus einem int* ein int zu bekommen, muss man sich die Variable, die die gespeicherte Adresse hat, holen, und zwar so:

    int a=2;
    int* b= &a; //Adresse von a - &a
    cout << (*b) //Ausgabe: 2
    

    Verstanden? War für mich auch ziemlich schwierig das zu Verstehen, zumal es auch ohne geht, in Pascal zum Beispiel, aber das geht zu weit.



  • Hallo,

    hä schrieb:

    Hallo,
    ich muss euch wieder etwas fragen:

    Zeiger:

    int* p : bedeutet:

    1. p ist ein Zeiger auf int (wieso soll ein zeiger auf dem Typ int zeigen??)

    er zeigt nicht auf _den_ Typ int, sondern, wie du geschrieben hast, auf einen
    int. Z. B.:

    int i = 5;
    int *p = &i; //p ist ein zeiger auf einen int; zeigt hier auf i
    
    1. p zeigt irgendwo hin. (verstehe ich)

    int* foo ( int value){ ... } : bedeutet:

    1. die funktion ist ein Zeiger auf dem Typ int? wie die 1. frage

    Die Funktion erwartet als Parameter eine int-Variable und liefert dir einen
    Zeiger auf einen Integer zurueck. Z. B. koennte die Funktion so aussehen:

    int* foo(int value) {
        int *bar = new int[value]; //speicher reservieren
        return bar; //zeiger auf einen integer zurueckgeben
    }
    
    //irgendwo in main oder so
    int *foobar = foo(10); //liefert einen zeiger auf ein int-array mit der
                           //groesse 10
    

    Sind natuerlich bloede Beispiele, aber ich hoffe sie sind verstaendlich.

    mfg
    v R



  • hä schrieb:

    int* p : bedeutet:

    1. p ist ein Zeiger auf int (wieso soll ein zeiger auf dem Typ int zeigen??)
    2. p zeigt irgendwo hin. (verstehe ich)

    Das kannst du verstehen wie du willst, und du wirst auch einige Meinungen dazu hören. Aber die einzige Interpretation, die es auch ermöglicht, kompliziertere Deklarationen zu verstehen, ist folgende: p ist etwas, das ich dereferenzieren kann, um einen int zu erhalten (folglich ist p ein Zeiger auf einen int).

    int* foo ( int value){ ... } : bedeutet:

    1. die funktion ist ein Zeiger auf dem Typ int? wie die 1. frage

    foo ist etwas, das ich aufrufen kann (mit einem int-Argument). Dann erhalte ich etwas, das ich dereferenzieren kann, um einen int zu erhalten. Folglich ist foo eine Funktion, die einen Zeiger auf ein int zurückliefert.

    Wichtig ist die Klammersetzung. Beispiel als Gegensatz zu eben: int (*bar)();
    bar kann ich dereferenzieren. Dann erhalte ich etwas, das ich aufrufen kann, und das wiederum ergibt ein int. Daraus folgt, dass bar ein Zeiger auf eine Funktion ist, die ein int zurückliefert.



  • unzi schrieb:

    zumal es auch ohne geht, in Pascal zum Beispiel, aber das geht zu weit.

    Quatsch, da gab's auch Pointer (und brauchte man auch).

    Jockel



  • Ok, danke euch, jetzt weiß ich ein bißchen mehr über Zeiger. 🙂



  • Du solltest dir in dem Zusammenhang auch Referenzen angucken. In C++ sind die oftmals die elegantere und bessere Lösung, um Probleme zu lösen, die in C nur mit Zeigern machbar sind.




Log in to reply