C-zeiger auf zeiger, malloc, calloc

[bleicher]

Grüße,
dank hiesiger freundlicher untersützunggelang es mit die zeiger weitgehen zu verstehen, ABER

3 tage im debugg modus brachten nichts -

GEgeben:

in der main definiere ich einen char zeiger

char *r;

den übergebe ich an eine externe funktion

initArray(&r, size); //size sei int mit wert

die funktin slebst bestand aus

void initArray(char**r, int size){
*r=(char*)malloc(size+1);
}

das problem:

ich fand kein weg auf den array als solchen innerhalb dieser initArray zuzugreifen - was reinzuschrieben war unmöglich.

übrigens - rauszufinden, dass speicher in 16byte schritten (auf den getesteten systemen) reserviert wird, war etwas nervig :/

und eine kleinigkeit - die idee war, den array gegebener länge mit 0 zu füllen - calloc sollte es der beschreibung nahc tun, ich bekam aber konsequent ein leere array der länge 0 bei verwendung

*r=(char*)calloc(size+1, 1);

habe ich es missverstanden?

ich danke wieder mal im voraus :)
MFG
bleicher

[mrjerk]

Hallo,
Meine C-Tage sind lange her, aber...

übrigens - rauszufinden, dass speicher in 16byte schritten (auf den getesteten systemen) reserviert wird, war etwas nervig :/

Der Speicher, den Du bei malloc haben willst, wird eigentlich immer in Bytes angegeben.
Wieviel Bytes du aber für was brauchst, ist i.d.Regel Architektur abhängig.
Der Speicherbedarf für einen Zeiger z.b. kann 2 Byte (16-Bit-Architektur), 4 Byte (32-Bit-Architektur) oder auch mehr haben.
Mit der Funktion "sizeof" kannst Du ermitteln, wie viele Bytes Dein Datentyp braucht:

int *integerArray = (int *) malloc(sizeof(int)*10);

liefert Dir ein Integer-Array für 10 Integer-Werte.

int **integerPtrArray = (int *) malloc sizeof (int *)*10);

liefert Dir ein Array von 10 Integer Arrays :)

void initArray(char**r, int size){
*r=(char*)malloc(size+1);
}

das problem:

ich fand kein weg auf den array als solchen innerhalb dieser initArray zuzugreifen - was reinzuschrieben war unmöglich.

Wie hast Du denn versucht reinzuschreiben? Nehmen wir an, Dein Array ist groß genug (das müsstest Du natürlich sicherstellen, s.o.), so müsste das so gehen:

void initArray(char**r, int size){
 *r=(char*)malloc(size+1);
 *r[0] = 'a';
 *r[1] = 'b';
 *r[2] = '\0'
}

oder natürlich:

**r = 'a';
*r++;
**r = 'b';
usw

(da mag ich mich jetzt aber auch irren im Syntax)

So long,
Jörg

[mrjerk]

Ich nochmal,

int **integerPtrArray = (int *) malloc sizeof (int *)*10);

liefert Dir ein Array von 10 Integer Arrays :)

missverständlich formuliert und falsch gecastet ebenfalls:

Das liefert Dir ein Array von 10 "Pointern", die aber selbst noch auf keinen Speicher zeigen!

Es müsste heissen:

int **integerPtrArray = (int **) malloc (sizeof (int *) * 10);
for (int i = 0; i < 10; i++) {
   integerPtrArray[i] = (int *) malloc (sizeof(int) * 10);
}
Jetzt hast Du ein Array von 10 Arrays, die jeweils Platz für 10 Integers bieten.

[Der Martin]

Hallo,

dank hiesiger freundlicher untersützunggelang es mit die zeiger weitgehen zu verstehen

wenn du das Thema "Zeiger" vollständig verstanden hast, bist du einen riesigen Schritt weiter auf dem Weg zur Beherrschung von C.

in der main definiere ich einen char zeiger
char *r;

den übergebe ich an eine externe funktion
initArray(&r, size); //size sei int mit wert

die funktin slebst bestand aus
void initArray(char**r, int size){
*r=(char*)malloc(size+1);
}

Das passt erstmal alles gut zusammen.

ich fand kein weg auf den array als solchen innerhalb dieser initArray zuzugreifen - was reinzuschrieben war unmöglich.

Wie hast du es versucht? Mit *r[0], *r[1], *r[2] ... funktioniert es, auch strncpy(*r, originalstring, size); wäre in Ordnung.

übrigens - rauszufinden, dass speicher in 16byte schritten (auf den getesteten systemen) reserviert wird, war etwas nervig :/

Nanu? Auf welcher Plattform übst du? DOS? AFAIR bedient Windows Speicheranfragen in 1kB-Schritten. Ah, shit - malloc() geht ja erst noch durch die C-Standardbibliothek, bevor es an die zuständige Funktion des Betriebssystems durchgereicht wird. Wer weiß, was malloc() da intern noch alles zwischenspeichert und vermittelt.
Wie hast du das mit den 16 Byte herausgefunden?

die idee war, den array gegebener länge mit 0 zu füllen - calloc sollte es der beschreibung nahc tun, ich bekam aber konsequent ein leere array der länge 0 bei verwendung
*r=(char*)calloc(size+1, 1);

Wie hast du die Länge 0 festgestellt? Etwa mit strlen()? Bedenke, dass Strings in C mit einem Nullbyte beendet werden. Das erste Nullbyte markiert also das Ende des Strings, unabhängig davon, wie groß der reservierte Speicherblock ist. Wenn du also einen Bereich mit Nullbytes initialisierst, liefert strlen() immer eine Länge von 0.
Faustregel: Wenn malloc() oder seine Verwandten ein Ergebnis ungleich NULL liefern, dann hast du einen Speicherblock bekommen, der mindestens so groß ist, wie du bestellt hat. Es gibt leider keine dokumentierte Möglichkeit, die tatsächliche Größe dieses Speicherblocks abzufragen.

habe ich es missverstanden?

Vielleicht.

So long,
 Martin

[bleicher]

Grüße,

Wie hast du die Länge 0 festgestellt? Etwa mit strlen()?

nein - jegliche versuche was reinzuschreiben endeten mit nichts - keine fehlermeldungen, aber es wurde auch kein wert reingeschrieben
MFG
bleicher