C++ Zeiger



  • Hey,
    ich habe mal eine Frage zu den Zeigern.
    Irgendwie verstehe ich die Zeiger nicht richtig.
    Ich habe das Buch der C++ Programmierer, und teilweise sind da Zeiger auf Zeiger und darauf wiederum auch Zeiger...
    Und jedzt habe ich schon seit 2 Wochen nichts mehr mit C++ gemacht, da mir die Lust fehlt mit diesen doofen Zeigern.
    Sind Zeiger für spätere Programme wichtig, und sollte ich das Kapitel noch einmal von vorne lesen(denn ich bin damit durch und ja das wars auch)?

    Gruß



  • Zeiger sind auf unterster Ebene einer der Gründe warum C/C++ so flott ist.
    Man muss sie am Anfang vielleicht nicht sofort komplett verstehen oder immer weiter damit arbeiten (genaugenommen wird auch davon abgeraten mit rohen Zeigern [zu viel] zu arbeiten, gerade hier im Forum). Aber ein paar Grundlagen sind schon wichtig für das weitere Verständnis und später wirst du auch immer wieder darüber stolpern.


  • Mod

    Skym0sh0 schrieb:

    Zeiger sind auf unterster Ebene einer der Gründe warum C/C++ so flott ist.

    Wo ist denn da der Zusammenhang? Jede halbwegs brauchbare Sprache kennt Zeiger, sei es offen oder versteckt, sonst könnte man gar keine komplexen Programme schreiben. Auch als "langsam" gebrandmarkte Sprachen, wie Java. Gerade Java, wo fast alles über Pointer geht; sie werden dort bloß anders genannt.



  • Aber genau das meine ich.

    ALs ich vor Jahren mich am Zeigerkapitel versucht habe, habe ich lange Zeit immer nur Bahnhof verstanden und wusste nicht so recht wo mir der Kopf steht. (Anmerkung: Ich kam damals von Java)

    Technisch gesehen sind Referenzen, Referenzvariablen(wie in Java) und Zeiger bis auf etwas Syntaxzucker das gleiche.

    Aber während Java so aussieht (für Anfänger), als ob es keine Zeiger gibt (man merkt das ja wirklich nur beim Call-By-Value, wenn man die eigentliche Referenzvariable neu belegen will) und sich auch so anfühlt, ist die C(++) dann doch weit komplexer. Und spätestens wenn es dann auch um Ressourcenverwaltung geht denkt sich jeder Anfänger doch wahrscheinlich, dass Zeiger etwas unheimlich magisches und komplexes sind.

    So jedenfalls fühlte es sich für mich an.



  • Also habe mich entschieden das Kapitel erneuert zu lesen :I
    Hier ist jedzt mal ein kleines Beispiel.

    int main(){
        int i=99;
        int *ip;
        ip=&i;
        std::cout << *ip;
        return 0;
    }
    

    Wieso

    ip=&i;
    

    und nicht

    *ip=&i;
    

    ?



  • Weil du nicht den Wert, auf den ip zeigt verändern willst, sondern worauf er zeigt.
    ip speichert eine Adresse, *ip einen Wert und zwar den an Adresse in ip.

    An dem Adressoperator (&) merkst du, dass du es mit einer Adresse zu tun hast.



  • Weil ip der Zeiger ist und *ip das, worauf er zeigt. Du könntest

    ip = &i;
    *ip = 100;
    
    std::cout << i << '\n';
    

    schreiben, und würdest als Ausgabe 100 bekommen. Hier zeigt dann ip auf i, und *ip ist i.



  • Okay danke für die Antworten 😃
    Wenn ich mehr fragen habe stelle ich sie einfach hier rein :p


  • Mod

    @Skym0sh0: Ja, aber der Grund, warum C und C++ schnell sind, ist ein ganz anderer.



  • Hier bin ich wieder :p

    char r='u';
        void *i;
        i=&r;
        std::cout << *i;
    

    Warum geht das nicht?
    Soweit ich weiß, ist der Zeiger doch auf ein Unbekannten Typ, und so sollte es gehen.



  • Richtig, i zeigt auf einen unbekannten Typ. Deswegen kann er *i nicht auswerten, weil er nicht weiß, auf welchen Typ i zeigt.



  • SeppJ schrieb:

    @Skym0sh0: Ja, aber der Grund, warum C und C++ schnell sind, ist ein ganz anderer.

    Ja da hast du recht.
    Ich merk grad, dass ich etwas um die Ecke, bzw. vorschnell gedacht habe:
    Einer der Gründe, warum man mit C/C++ mehr Speed rausholen kann ist, dass man sich selber um Speicherallokation bzw. Deallokationen kümmern kann. Wenn man da Dinge weiss, wie Speicher wann und in welcher Menge gebraucht wird, kann man schön optimieren.
    Mein Gedanke war, dass dabei ja mehr oder weniger viel Zeiger gebraucht werden. Daher meine ursprüngliche Aussage.

    Sorry für die ungenauen Aussagen, das sollte ich echt mal in naher Zukunft ausmerzen. -.-'



  • Also kann das gar nicht funktionieren?
    Und wenn ja, weil so wie ich das im Buch verstanden habe ist das auch ein "Vorteil" von den Zeigern.



  • Sry für Doppelpost.
    Hier nochmal einwenig Code:

    char *cp; // Zeiger auf char
        void *vp; // Zeiger auf void
        vp = cp;
    

    Das geht, aber ich kann cp keinen Wert wie z.B. "u" zuweisen.
    Wieso nicht? :I



  • *cp = 'u';
    

    Geht doch ?
    Mal davon abgesehen dass cp nirgendwohin zeigt...



  • Ich hasse Zeiger 😃
    Aber danke für die Antwort.



  • Halllo
    eine Verstädnisfrage habe ich mal:

    int ∗ip = &i;//SO weise ich dem Zeiger eine neue Adresse zu?
    ∗ip = 8;//So weise ich der Adresse einen neuen Wert zu?
    


  • Ups...
    Das sollen sternchen (*) sein. (∗)



  • int * ip = &i;
    *ip = 8;
    

    Wenn das der Code war, ja zu deiner Frage.



  • Nochmal kurz zur Erklärung:

    int i1, i2;
    
    int* pointer; // definiert einen pointer auf integer
    int* pointer = &i1; // definiert einen pointer auf integer, und weißt ihm die addresse von i1 zu
    
    //wenn du pointer schreibst greifst du auf die Adresse zu:
    pointer = &i2; //Weist pointer die Adresse von i2 zu
    std::cout << pointer; // gibt die adresse aus
    
    //wenn du *pointer schreibst gibst du den Wert aus auf den pointer zeigt
    *pointer = 42; //der wert ist jetzt 42
    std::cout << *pointer; //gibt 42 aus.
    

    Das Sternchen sorgt dafür dass der Pointer dereferenziert wird. Außer bei der Definition des Pointers, das ist vielleicht etwas verwirrend.


Log in to reply