4. Pointer/Zeiger(malloc)

Pointer/Zeiger(malloc)

  • ?

    Hallo zusammen!

    Ich hab mich schon mit Pointern befasst etc. ich weiß das man mit & auf die Adresse zugreift und mit * auf den Wert in der Adresse, wenn man das so sagen darf?

    Hier mal ein kleines Bsp-Programm:

    double* pointer=NULL;
double* pointer1=NULL;

//die beiden pointer zeigen auf nichts

pointer=malloc(sizeof(double)*5);//ich reserviere mir eine bestimmte Byteanzahl / von wo hole ich die Bytes? Arbeitsspeicher?
//pointer zeigt nun auf die "1. Stelle"(speicherstelle bzw. adresse?), die er von malloc bekommt, in dieser speicherstelle steht vermutlich nichts bzw. noch nichts.

pointer1=pointer;//ich weise hier die 1. adresse bzw. speicherstelle auf pointer1 zu --> später wenn pointer verändert wird z.b unterhalb in der for werden da werte in die adressen geschrieben, stehn dann in den adresse wo pointer1 hinzeigt die selben werte wie in den adressen wo pointer hinzeigt.
//Begründung: Ist das so weil man davor pointer1=pointer macht, d. h. man weist ja pointer1 die "1. adresse" von pointer zu --> pointer1 und pointer sind ident?

for(x=0; x<5; x++)
{
  *pointer=wert[x];//hier werden halt einfach werte in die Adressen auf der pointer draufzeigt hineingeschrieben
  pointer++;//hier zeigt der pointer dann immer um einer Adresse weiter
}

return(pointer1);

    Sagt mir bitte ob meine Begründung stimmt bzw. wenn sie nicht stimmt sagt mir bitte wieso das nicht so ist etc.

    Danke!

    mfg homer

    0
  • Mod

    Im großen und ganzen richtig.

    0

  • Das kann man so gelten lassen.

    pointer1 hast du nur deswegen gebraucht, um dir die malloc-Adresse zu merken, für das abschließende return, da du pointer veränderst.

    Dies ist prinzipiell nicht notwendig, da du den Subskript-Operator [] auch direkt auf pointer anwenden kannst und somit pointer selbst nicht verändern musst.

    double* pointer=malloc(sizeof(double)*5);
for(x=0; x<5; x++)
{
  pointer[x]=wert[x];
}

return(pointer);
    0
  • ?

    Ok, danke dann habe ich das soweit verstanden.

    Aber nun frage ich mich warum ich da überhaupt einen Pointer verwendet habe? Ich könnte ja das gleich am Anfang mit Arrays machen und somit erspare ich mir malloc.

    Einerseits hätte ich einen Grund jetzt: Arrays kann man ja nicht zurückgeben, aber Pointer schon... --> wenn ich den Pointer zurück geben dann habe ich die Werte im Hauptprogramm, würde ich es mit Array machen dann blieben sie wahrscheinlich nur im Unterprogramm.

    Was sagt ihr dazu?

    0
  • C

    Die Größe von Arrays muss zur Compilezeit bekannt sein, malloc kannst du alles übergeben. Das mit der Lebenszeit hast du ja schon erwähnt. Zudem ist der Stack auf den meisten Rechnern wesentlich kleiner(~1MB) als der Heap, also wenn du wirklich viel reservieren willst, dann nimm malloc.

    Zu dem Zurückgeben von Pointern: Nicht unbedingt eine gute Idee. Üblicherweise möchte man, dass die Instanz die Speicher reserviert ihn auch wieder frei gibt. Da man in C keine Destruktoren wie in C++ hat, musst du hier meistens auf solche Konstrukte zurückgreifen:

    void foo(void *mem, size_t size); // Hier wird dann ein Pointer auf freien Speicher übergeben.

    Edit:
    Ich würde eher "an" statt "in" der Adresse sagen.
    Und bei ++pointer wird der Pointer nicht um ein Byte verschoben, sondern um sizeof(*pointer) Byte. Kann sein dass du das bereits weißt, wollte es nur noch mal hervorheben.

    0
Anmelden zum Antworten