Adresse eines Arrays einem Pointer zuweisen und löschen

[Ich (Gast)]

Hi alle miteinder,

Ich hab eine eher allgemeine Frage zur C-Programmierung. Wenn ich ein 
Pointer erzeuge und diese Adresse einem Array zuweise, kann ich dann den 
Pointer mit free freigeben oder ist das Array dann auch futsch?

z.B

uint8_t *test1;
test1=(uint8_t*) malloc(3*sizeof(uint8_t));
uint8_t test2[3];

test2=test1;

Das ist jetzt ein triviales Bespiel aber es hilft hoffentlich mein 
Problem zu verstehen.

Vielen Dank im Vorraus

[Peter II (Gast)]

Ich schrieb:
> kann ich dann den
> Pointer mit free freigeben oder ist das Array dann auch futsch?

ja, denn man überhaupt ja free nur eine Adresse, woher die kommt ist 
egal.

[Ich (Gast)]

Ok danke!

[Rufus Τ. F. (rufus)]

 
uint8_t *test1;

test1 = (uint8_t*) malloc(3*sizeof(uint8_t));

uint8_t test2[3];

test2 = test1; // ####

Das geht nicht. test2 kann nichts zugewiesen werden.

[Ich (Gast)]

Rufus Τ. Firefly schrieb:
> Das geht nicht. test2 kann nichts zugewiesen werden.

Wieso geht das nicht, ich weise dem Array doch einfach nur die Adresse 
zu

[Karl H. (kbuchegg)]

Ich schrieb:
> Rufus Τ. Firefly schrieb:
>> Das geht nicht. test2 kann nichts zugewiesen werden.
>
> Wieso geht das nicht, ich weise dem Array doch einfach nur die Adresse
> zu

Du kannst einem Array keine Adresse zuweisen.
Ein Array ist ein Objekt im Speicher. Das hat schon eine Adresse.

[Karl H. (kbuchegg)]

Ich schrieb:

Deine ganze Ausdrucksweise zeigt, dass du da ein paar Dinge nicht 
verstanden hast.

>  Wenn ich ein
> Pointer erzeuge

Du erzeugst hier

  test1=(uint8_t*) malloc(3*sizeof(uint8_t));

aber keinen Pointer.
Die Pointer-Variable hast du bereits!
Du erzeugst hier dynamisch ein Array, genauer gesagt eigentlich einen 
Speicherbereich mit einer bestimmten Größe und weist dessen Adresse der 
Pointer Variablen zu.

> und diese Adresse einem Array zuweise, kann ich dann den
> Pointer mit free freigeben

Du gibst auch nicht den Pointer frei sondern das worauf der Pointer 
zeigt.

[Karl H. (kbuchegg)]

Wenn du diese Variablen Defintionen hast

uint8_t *test1;
uint8_t test2[3];

dann sieht die Sache im Speicher so aus

   test2
   +---+     test1
   |   |     +--------+
   +---+     |        |
   |   |     +--------+
   +---+
   |   |
   +---+

jetzt kommt der malloc zum Zug und reserviert irgendwo im Speicher einen 
Speicherbereich mit der Größe von 3 Stück uint8_t

    ...    malloc(3*sizeof(uint8_t));

   test2
   +---+     test1
   |   |     +--------+
   +---+     |        |
   |   |     +--------+
   +---+
   |   |              +---+
   +---+              |   |
                      +---+
                      |   |
                      +---+
                      |   |
                      +---+

wegen der Zuweisung wird die Startadresse dieses Speicherbereichs in 
test1 eingetragen.

  test1 = (uint8_t*) malloc(3*sizeof(uint8_t));

   test2
   +---+     test1
   |   |     +--------+
   +---+     |   o    |
   |   |     +---|----+
   +---+         |
   |   |         |    +---+
   +---+         +--->|   |
                      +---+
                      |   |
                      +---+
                      |   |
                      +---+

Man sagt jetzt auch, test1 zeigt auf diesen Speicherbereich.

Die Zuwweisung geht deshalb, weil test1 so definiert ist

uint8_t *test1;

der Datentyp der Variablen ist 'uint8_t *'. Es ist also eine Variable, 
die auf einen Speicher zeigen kann.


Machst du dann einen

    free( test1 );

so wird der Speicher, auf den test1 gerade zeigt, wieder frei gegeben 
und landet wieder im Vorrat, aus dem sich andere Aufrufe von malloc 
bedienen, wenn sie Speicher reservieren sollen.

   test2
   +---+     test1
   |   |     +--------+
   +---+     |   o    |
   |   |     +---|----+
   +---+         |
   |   |         |    
   +---+         +--->

Beachte: Nur weil du einen free gemacht hast, bedeutet das nicht, dass 
dadurch der Pfeil, der von test1 ausgeht auch aufgelöst worden wäre. 
test1 zeigt immer noch auf denselben Speicherbereich. Nur ist dieser 
Speicherbereich nicht mehr zur Verwendung von deinem Programm 
reserviert!

Mit test2 hat das alles überhaupt nichts zu tun.
Dieses Array gammelt im Speicher einfach nur so vor sich hin.

[Karl H. (kbuchegg)]

Und PS:

Du sollst das Ergebnis eines malloc() nicht casten!

In C ist so ein Cast unnötig und kann dir unter Umständen, wenn es blöd 
läuft einen Fehler verdecken.
Will dein Compiler diesen Cast sehen, dann benutzt du keinen C Compiler 
sondern einen C++ Compiler. In diesem Fall solltest du anstelle von 
malloc besser new benutzen.

Fazit: In C braucht es den Cast nicht. Er ist in C kontraproduktiv.
In C++ würde es den Cast brauchen. Aber da benutzt man malloc nicht 
(ausser in Sonderfällen, wenn man ein Konglomerat aus C++ und C Code 
schreiben muss. Aber ich denke, soweit bist du noch nicht, dass das 
relevant wäre)

[Erik L. (erikl)]

Hallo zusammen,

wenn wir ein Skript hätten, was
- Beiträge von Karl-Heinz sucht
- mit den zugehörige Fragen alle zu einem PDF zusammenbaut

würde kein Verlag mehr ein C-Buch verkaufen können weil das PDF viel 
besser wäre.

Danke für die Mühe, Geduld und das Geschick!
Erik

[Johann L. (gjlayde)]

Ich schrieb:

> uint8_t test2[3];
> test2=test1;
>
> Das ist jetzt ein triviales Bespiel aber es hilft hoffentlich mein
> Problem zu verstehen.

Ja, das Problem ist offenbar ein nicht vorhandenes C-Buch.