✔ Konvertierung int* - char* - int*

[ibafluss]

Hey Leute!
Ich bin gerade am C++ lernen und bin jetzt im Buch "Thinking in C++" über eine Aufgabe gestolpert, die ich nicht ganz verstehe. Ich poste hier nur die wesentlichen Codeschnipsel:

struct Stash     // Sollte Hilfe bei der Speicherreservierung sein
{
    int size;                    // Die Grundgröße in Bytes, um die immer erhöht wird
    int quantity;                // Die Anzahl der Speichereinheiten
    int next;                    // Zeigt an, wo der unbenützte Speicher beginnt
    unsigned char *storage;      // Der reservierte Speicher

    void initialize (int size);     
    void cleanup();                
    int add (const void *element); 
    void *fetch (int index);
    int count();
    void inflate (int increase);
};

int Stash::add (const void *element)  // Funktion, um einen Wert im Speicher zu speichern
{
    unsigned char *e;
    int i, startBytes;

    if (next >= quantity)    // Next markiert das nächste leere Element
    {
        inflate (increment);    // Es wird wieder Speicher hinzugefügt
    }

    startBytes = next * size;          // In startBytes wird gespeichert, ab welchem Element der Speicher noch unbeschrieben ist
    e = (unsigned char *) element;     // e zeigt auf die angegebene Adresse. wird in unsigned char * umgewandelt, damit man mit allen Typen gleich verfahren kann

    for (i = 0; i < size; i++)    // Da e auf unsigned char * ist, ist jedes Element ein eigenes Byte, deshalb bis size
    {
        storage[startBytes+i] = e[i];
    }

    cout << endl << endl << endl;

    next++;

    return (next-1);
}

int main ()
{
    Stash intStash;

     intStash.initialize (sizeof (int));

    for (int i = 0; i < 99; i++)
    {
        intStash.add (&i);
    }

    for (int j = 0; j < intStash.count(); j++)
    {
        cout << "intStash.fetch (" << j << ") = " << * (int *)intStash.fetch (j) << endl;  // wieder auf int* zurückcasten
    }
}

Jetzt meine Frage:
In der main() wird in der 9.Zeile ein int* übergeben. Das wird dann in der Funktion add() zu einem unsigned char* gecastet. Nur was passiert dann in der for-Schleife im Speicher?

Wenn ich jetzt einen int-Wert (auf den der Zeiger zeigt) von z.B. 100000 habe: Wie wird die Zahl dann auf die char-Elemente aufgeteilt?
Am Schluss wird ja dann alles wieder mit fetch() ausgegeben.

Lg

 

[sheel]

Hi

was ist genau nicht klar?

Es wird ein 4-Byte-int übergeben (auf 32bit-Rechnern)
Das wird dann in add als 4 einzelne Byte (char) behandelt.

 

[ibafluss]

Ja was läuft da genau im Speicher ab?
Wenn ich jetzt einen Zeiger auf eine große Zahl übergebe und den Zeiger auf unsigned char* caste, dann wird ja die große Zahl irgendwie auf die Speicherbereich aufgeteilt oder?

Also zum Beispiel:

z zeigt auf 100000. Der Speicherblock: |_____|
Jetzt caste ich z auf unsigned char, dann zeigt z ja auf einen kleineren Teil: |_|_|_|_|
Jetzt muss die Zahl ja, wenn sie groß ist auf die Speicherblöcke aufgeteilt werden oder? Bzw. auf die ersten zwei oder drei, das hängt dann davon ab wie groß die Zahl ist verstehe ich das richtig?

Lg

 

[sheel]

Hi

im Speicher passiert überhauüt nichts.

Zuerst einmal, eine Zahl kann ja führene Nullen haben
und hat trotzdem noch immer den gleichen Wert. zB.
00123 = 123
Das gilt auch fürs Binärsystem (und jedes Andere, Hex. usw.)
00101 = 101

Eine 4-Byte-Zahl hat logischerweise 32 bit, 32 Binärstellen.
zB.
100101001010000111111110000
ist in 32 Stellen
00000100101001010000111111110000
Jetzt wird die 32-Wurscht gedanklich in 4 Achterblöcke aufgeteilt:
00000100 10100101 00001111 11110000
Und das sind sie char-Werte...

Eigentlich kommt noch die Endianess dazu (Reihenfolge der Bit schon im int etwas verdreht,
verglichen mit menschlicher Umrechnung), aber das ändert nichts an der Aufteilung.

 

[ibafluss]

Vielen Dank

Lg