Frage zu Pointer



  • Ich hab letzdens folgenden Code gesehen:

    Die Variable start und ende waren in dem Code vom Datentyp unsigned char
    
    *((DWORD*)(start + 1)) = (DWORD)(ende - start) - 5;
    

    Jetzt versuche ich gerade den Code zu verstehen:

    (DWORD)(start)=var;    //Schreibt den Wert von var IN die Variable location rein
    
    (DWORD*)(start+1)=var;  // Wieso akzeptiert die C++ Syntax das nicht?
                           //  Fehlermeldung: L-Wert erwartet 
                           //  Kp was das heissen soll.
    
    So funktioniert es jedoch:
    
    *((DWORD*)(start+1))=var; // Schreibt an die Adresse der Variable start+1 den Wert der Variable var
    

    ( (DWORD) (start+1) )= var;

    Was sagt man mit dem ersten * aus?

    Meiner Theorie nach müsste es ja mit (DWORD*)(start+1)=var;



  • *((DWORD*)(start + 1)); // Interpretiert start+1 als DWORD* (C-style Cast) und derefenziert diesen
    

    Das ist alles unglaublich häßlich.
    Außerdem nehme ich an, dass start und ende unsigned char* sind.

    Wenn Du den Teil verstanden hast (casten und dereferenzieren) kannst Du den Rest gut und gerne vergessen... 🙂



  • OOps da hab ich wohl was vergessen.^^

    Meiner Theorie nach müsste es ja mit (DWORD*)(start+1)=var; auch gehen.

    Btw. da wo was verändert wurde an der Stelle wurden dem Process mit VirtualProtect die entsprechenden Rechte geben.



  • Wie würde das den in C++ aussehen?

    *(  static_cast<DWORD*>(loc) ) = var;
    

    Ich habs eben mal versucht aber anscheind kenne ich nicht die richtige Syntax an der Stelle.

    Der Compiler sagt: Typumwandlung von 'unsigned char *' nach 'unsigned long *' nicht zulässig

    Da denke ich dann, wieso mit dem C-Cast geht es doch.^^

    Ich hab auch schon mal ein paar Sachen bezüglich casts gelesen aber so ein Pointer wirr warr wurde dort nicht erklärt. 😞



  • ZeigerLehrling schrieb:

    Meiner Theorie nach müsste es ja mit (DWORD*)(start+1)=var; auch gehen.

    Da ist ja nur noch der Cast, und keine Dereferenzierung mehr.
    Wie würdest Du denn beschreiben, was da passiert?

    ZeigerLehrling schrieb:

    Wie würde das den in C++ aussehen?

    *(  static_cast<DWORD*>(loc) ) = var;
    

    reinterpret_cast



  • ZeigerLehrling schrieb:

    Meiner Theorie nach müsste es ja mit (DWORD*)(start+1)=var; auch gehen.

    Furble Wurble schrieb:

    Wie würdest Du denn beschreiben, was da passiert?

    Ich würde sagen start wird zu einem DWORD Pointer gecastet und an die Adresse von start+1 wird der Inhalt aus der Variable var geschrieben.

    So dachte ich jedenfalls wäre es.^^



  • ZeigerLehrling schrieb:

    ZeigerLehrling schrieb:

    Meiner Theorie nach müsste es ja mit (DWORD*)(start+1)=var; auch gehen.

    Furble Wurble schrieb:

    Wie würdest Du denn beschreiben, was da passiert?

    Ich würde sagen start wird zu einem DWORD Pointer gecastet und an die Adresse von start+1 wird der Inhalt aus der Variable var geschrieben.

    Da hat sich aber noch die Dereferenzierung in der Formulierung versteckt ('an die Adresse...'). 🙂

    Eigentlich steht da nur dass Du einem DWORD* was zuweist. Das impliziert, dass var auch ein DWORD* ist.

    Richtig?



  • Kennt wer eine gute Anlaufstelle wo man sich über die komplizierteren Pointer Fälle informieren kann?

    Ich finde immer nur erklärungen zu so simplen Pointer fällen wie z.b.:

    int var=8;
    int *ptr=&var;
    


  • Furble Wurble schrieb:

    Eigentlich steht da nur dass Du einem DWORD* was zuweist. Das impliziert, dass var auch ein DWORD* ist.

    Richtig?

    Mhhm, stimmt folgendes geht ja z.b. nicht:

    DWORD var;
    DWORD *ptr = var;
    

    Ich denke mal das: (DWORD*)(start+1)=var;
    So ähnlich ist wie:

    DWORD var=8;
    DWORD *start=&var;
    ptr[0]=99; // Ersetzt die 8 von var durch 99
    cout<<var<<endl;
    


  • Das Video, von einer Vorlesung aus einer australischen Uni, fand ich ganz nett:

    21:Everything u need 2 know about pointers -Richard Buckland



  • ZeigerLehrling schrieb:

    Ich denke mal das: (DWORD*)(start+1)=var;
    So ähnlich ist wie:

    DWORD var=8;
    DWORD *start=&var;
    ptr[0]=99; // Ersetzt die 8 von var durch 99
    cout<<var<<endl;
    

    ptr[0](sic!) dereferenziert aber wieder.

    ptr[0]
    ist wie
    *ptr
    ist wie
    *(ptr) (so wie in dem Eingangsbeispiel)
    und siehst Du diese Dereferenzierung in (DWORD*)(start+1)=var; ?

    ZeigerLehrling schrieb:

    Kennt wer eine gute Anlaufstelle wo man sich über die komplizierteren Pointer Fälle informieren kann?

    Das hier ist aber nicht sonderlich kompliziert.

    Ich wiederhole mich gerne: Wenn Du Cast und Dereferenzierung verstanden hast, ist das schon alles, was Du aus dem Codeschnipsel mitnehmen solltest.



  • Furble Wurble schrieb:

    und siehst Du diese Dereferenzierung in (DWORD*)(start+1)=var;?

    Nein ^^

    @Grasshopper danke für den Link.

    Bei 15:25 in dem Video da sagt der Professor x = 2 das verstehe ich noch aber wieso soll dann der erste * (von rechts gelesen) = 4 sein?

    Kurz danach gibt der Professor auch auf ist ihm wohl auch zu verzweigt. 😃



  • Weil an Adresse 2 als Wert eine 4 steht. *2 bedeutet der Wert der an Adresse 2 steht. In x ist eine 2 gespeichert, nur x meint diese 2. *x meint den Wert der am Adresse 2 steht und das ist hier 4.

    Ein Problem mit Zeiger ist deren Syntax, das Dereferenzierungssymbol * ist gleich dem Symbol um einen Zeiger zu deklarieren. Ein Symbol, zwei Bedeutungen und dies an einer der gefährlichsten Stellen in der Sprache. Das ist in meinen Augen ein ganz dicker Designfehler.

    Nur noch gêtoppt von der "Von Neumann Architektur"(Speicher für Code und Daten können im selben Bereich liegen), eine Einladung für Hacker^^


Log in to reply