Zeiger und deren Größe

supersass1

Hi,
ich beschäftge mich ein wenig mit den Zeigern und möchte deren Funktionsweise etwas mehr verstehen. Dazu habe ich ein kleines Testprogramm geschrieben:

int main()
{
    printf("Pointer und deren Groessen\n");
    int Feld[10];
    int *Pointer;
    Pointer = &Feld[0];
    printf("Pointer: %d und Groesse: %d\n", Pointer, sizeof(Pointer));
    Pointer = &Feld[2];
    printf("Pointer: %d und Groesse: %d\n", Pointer, sizeof(Pointer));
    Pointer = Feld;
    printf("Pointer: %d und Groesse: %d\n", Pointer, sizeof(Pointer));
    Pointer = Pointer + 1;
    printf("Pointer: %d und Groesse: %d\n", Pointer, sizeof(Pointer));

    printf("\nDynamische Pointer\n");
    float *pFloat1 = NULL;
    float *pFloat2 = NULL;
    pFloat1 = (float *) malloc(100); // 100 Byte allozieren
    pFloat2 = (float *) calloc(25,sizeof(float)); // 25x4 Byte allozieren
    if ((pFloat1 != NULL) && (pFloat2 != NULL))
        // malloc und calloc liefer NULL bei zu großem Speicherbedarf
    {
        // Speicher verwenden
        printf("Groesse von p1: %d und p2: %d\n", sizeof(pFloat1), sizeof(pFloat2));
        free(pFloat1);
        free(pFloat2);
        // Speicher freigeben
        printf("nach Freigabe: p1: %d und p2: %d\n", sizeof(pFloat1), sizeof(pFloat2));
    }
    else
        // Fehlermeldung
        printf("Fehler\n.");

    return (EXIT_SUCCESS);
}

Der obere Teil ist relativ unterinteressant, spannend wird es ab Zeile 15. Meine Frage ist, warum die Größe jedes Mal 4 beträgt. Ich hätte vermutet, dass es 100 Bit (also 12 Byte) sind und nach der Freigabe erst 4. Oder stimmt da was im Code nicht, oder ist das nur der maximal Speicherplatz, der mit malloc() angegeben wird.
Oder anders gefragt, wie schaffe ich es, dass sich der Wert von sizeof() verändern?

Liebe Grüße

cooky451

1. Forderst du mit malloc(100) 100 Byte und nicht 100 Bit an und
2. gibt sizeof() die Größe des übergebenen Objekts zurück, was in dem Fall ein Pointer ist und dieser scheint auf deinem System halt nunmal 4 Byte groß zu sein. Die Größe eines Pointers ändert sich nicht, nur weil er auf etwas anderes zeigt. Du kannst mit sizeof() nicht bestimmen wie viel beschreibbaren Speicher du da jetzt zur Verfügung hast.

supersass1

Du kannst mit sizeof() nicht bestimmen wie viel beschreibbaren Speicher du da jetzt zur Verfügung hast.

und gibt es eine Funktion, die mir genau das ausgibt?

SG1

Nein. Ist aber ja auch nicht nötig, schliesslich übergibst Du malloc() ja, wieviel Speicher Du brauchst.

supersass1 schrieb:

und gibt es eine Funktion, die mir genau das ausgibt?

Nein.
Das musst du dir merken und den Funktionen als extra Parameter mitgeben.
Siehe z.B. fgets()

Wutz

Du hast noch nicht richtig verstanden, was ein Zeiger ist.
Ein Zeiger ist, wie andere Variablen auch, zunächst erstmal nichts anderes als ein Verweis auf einen Speicherbereich.
Definierst du etwas als Zeiger, belegt der Compiler (d.h. der Compiler generiert Code, der dieses tut) einen Speicherbereich zur Aufnahme einer Adresse. Dies sind bei 32Bit Compilern sinnigerweise 4 Byte.
sizeof(Zeiger) gibt also die Größe des für die Aufnahme einer Adresse notwendigen Speicherbereiches zurück und NICHT, wie du vermutest, die Größe des Speicherbereiches, AUF DEN diese Adresse gerade zeigt.
Dieser Nutzdatenbereich muss auch erst belegt werden, z.B. mit malloc.
Und wenn du jetzt noch weißt, wo der Unterschied zwischen dem o.g. Zeigerverhalten und einem Array liegt, hast du eine ganz wichtige, wenn nicht die wichtigste Grundlage von C verstanden (und damit vielen hier schreibenden Personen und solchen, die sich sonst noch angeblich professionell mit C befassen etwas voraus).

EOP

Zeiger und die Objekte auf die gezeigt werden verhalten sich ungefähr so zueinander wie eine Hausnummer und das Objekt Haus selbst.

Die Hausnummer enthält kein Haus, sie enthält nur die Adresse.

Wenn du sizeof(Hausnummer) abfrägst erhälst du demzufolge 12x12 cm (die Größe der Hausnummer) und nicht 250 m3 (die Größe des Hauses).

Wutz schrieb:

<TROMMELWIRBEL: AN, LAUTSTAERKE: VOLLES ROHR, DASS DER BODEN BEBT.>
Du hast noch nicht richtig verstanden, was ein Zeiger ist.
Ein Zeiger ist, wie andere Variablen auch, zunï¿½chst erstmal nichts anderes als ein Verweis auf einen Speicherbereich.
Definierst du etwas als Zeiger, belegt der Compiler (d.h. der Compiler generiert Code, der dieses tut) einen Speicherbereich zur Aufnahme einer Adresse. Dies sind bei 32Bit Compilern sinnigerweise 4 Byte.
sizeof(Zeiger) gibt also die Grï¿½ï¿½e des fï¿½r die Aufnahme einer Adresse notwendigen Speicherbereiches zurï¿½ck und NICHT, wie du vermutest, die Grï¿½ï¿½e des Speicherbereiches, AUF DEN diese Adresse gerade zeigt.
Dieser Nutzdatenbereich muss auch erst belegt werden, z.B. mit malloc.
Und wenn du jetzt noch weiï¿½t, wo der Unterschied zwischen dem o.g. Zeigerverhalten und einem Array liegt, hast du eine ganz wichtige, wenn nicht die wichtigste Grundlage von C verstanden (und damit vielen hier schreibenden Personen und solchen, die sich sonst noch angeblich professionell mit C befassen etwas voraus).
</TROMMELWIRBEL: AUS(VORUEBERGEHEND).>