3. Zeiger

Zeiger

  • ?

    Hallo,

    was passiert eigentlich bei Folgendem:

    int tueWas(unsigend int* i,int len)
{
    for (int x=0; x<len; x++) cout << i[x] << endl;
}

...
{
    char* daten = "Hallo Pointer";
    tueWas((unsigned int*)daten,strlen(daten));
}

    Vielen Dank im voraus.

    0
  • V

    Hallo,

    Damit es etwas klarer wird:

    Du hast folgende Speicherstellen:

    0x00400000 <----- i
    0x00400001 <----- i + 1
    0x00400002 <----- i + 2
    0x00400003 <----- i + 3

    mit i[2] wuerdest du auf das Zeichen an der zugreifen, welches an der
    Speicherstelle 0x00400002 abgespeichert ist. Du koenntest den Zugriff auch
    so schreiben, was vielleicht der o. darstellung naeher kommt:
    *(i + 2) oder fuer dein Beispiel *(i + x)

    Sagen wir einfach mal, x zeigt auf die Basisadresse des Arrays. Willst du
    auf die x-te Adresse zugreifen, musst du x zu i hinzuaddieren und das ganze
    dereferenzieren.

    mfg
    v R

    0
  • V

    [edit]
    sry doppelpost
    [/edit]

    mfg
    v R

    0
  • ?

    Danke für deine Antwort.

    Aber dann müsste doch folgendes das Gleiche Ergebnis liefern:

    int tueWas(int *data,int size)
{
    int     val  = 1;

    for ( inti=0; i<size; i++ )     
        lcaVal = (3*val) + data[i];    

    return (val);
}

...
{
    char* data1 = "HALLO";
    char* data2 = "HALLO 2";
    char  data2[] = "HALLO";

    cout << tueWas((int*)data1,5);
    cout << tueWas((int*)data2,5);
    cout << tueWas((int*)data3,5);
}

    Tuts aber nicht. But Why?

    0
  • G

    Was V.R. erzählt stimmt nicht ganz. Da i ein Zeiger auf unsigned int ist, wird, zumindest auf 32-bit Plattformen, folgendermassen auf den Speicher zugegriffen:

    0x00400000 <----- i + 0
    0x00400004 <----- i + 1
    0x00400008 <----- i + 2
    0x0040000c <----- i + 3
    ...

    0
  • V

    groovemaster2002 schrieb:

    Was V.R. erzählt stimmt nicht ganz. Da i ein Zeiger auf unsigned int wird, zumindest auf 32-bit Plattformen, folgendermassen auf den Speicher zugegriffen:

    0x00400000 <----- i + 0
    0x00400004 <----- i + 1
    0x00400008 <----- i + 2
    0x0040000c <----- i + 3
    ...

    Stimmt, zeiger haben auf 32-Bit Systemen eine groesse von 32-Bit. Sry for mistake.

    Felix: Wie ist die Ausgabe? Uebrigens gibst du immer 1 zurueck.

    mfg
    v R

    0
  • ?

    Ich müsste natürlich das Ergebnis der Addition in val schrieben, ok.

    Aber das ist nicht das Problem.
    Ich bekommen immer unterschiedliche Werte zurück. Bis zur zweiten Stellen gleichen sich diese noch, dann aber nicht mehr.
    Dies dürfet doch laut deiner Aussage nicht sein. Da alle Zeiger auf Adressen mit den geleichen Wert zeigen, zumindest von 0 bis 5 sind die Werte gleich. Aber mehr Stellen soll er ja auch nicht verwenden.

    Eine Idee was ich falsche mache?

    0
  • V

    Hallo,

    das Problem ist, dass das Programm nicht das macht was es tun soll und du es
    auch nicht so definiert hast. Wenn du den dezimalen Wert von bspw. 'H' zum
    Ergebnis von 3*val hinzuaddieren willst, musst du das so machen:

    val = 3*val+static_cast<int>(data[i]);

    [edit]
    Die Funktionsdefinition muss dann natuerlich so aussehen:

    int tueWas(char *data,int size)

    [/edit]

    Bei deinem Code wird data foellig anders interpretiert und zwar als int-Array.

    Deswegen hast du auch diese komischen Werte. Auszug aus meinem Watch-Fenster:

    (char*)data:
    (char)[0]='H'72(0x48)
    (char)[1]='A'65(0x41)
    (char)[2]='L'76(0x4c)
    (char)[3]='L'76(0x4c)
    (char)[4]='O'79(0x4f)
    (char)[5]='\0'0(0x00)

    Jetzt kommt das interessante: data als integer-array interpretiert

    (int)[0]=1280065864(0x4c4c4148)

    Ein Integer hat auf einem System die laenge von 32-Bit. Also werden die
    ersten 32-Bit Interpretiert (naemlich 0x48,0x41,0x4c,0x4c). Greifst du
    auf data[1] zurueck, werden die naechsten 32-Bit beginnend mit 0x41
    Interpretiert. In meinem Speicher sah es so aus, dass die 3 Array hinter-
    einander liegen (CBuilderX). D. h. die naechsten 32-Bit bestehen zum
    einen Teil aus dem Inhalt des aktuellen Arrays und zum anderen aus dem
    Inhalt der dahinter liegenden Daten (bei mir zum anderen Teil aus dem
    anderen Array).

    Daher kommt es zu den Unterschiedlichen ergebnissen, denn schliesslich
    sehen die Bits hinter den ersten 4 Bit unterschiedlich aus. Beim 2. Array
    gibt es noch ein Leerzeichen und die 2. Beim 3. Array wirds wohl so sein,
    dass es unterschiedliche Werte im Speicher hinter dem Array gibt.

    Ich hoffe ich habe das mit Hilfe des Debuggers nicht falsch interpretiert,
    aber ich wuesste nicht wie es sich sonst erklaren laesst.

    mfg
    v R

    0
  • ?

    Dankle für deine Hilfe.

    Ich habe vor deiner letzten Antwort auch noch mal überlegt :-), und bin auf das selbe Ergebnis gekommen. Ursache sind die unterschiedlichen Größe der Datentypen, wie du schon gesagt hast. Aber danke nochmal.

    0
Anmelden zum Antworten