[C] memcpy & delucidazione su dimensioni di variabili

[nomida]

Ciao ragazzi, in primis mi scuso gia' se non saro' chiaro.
Mi e' venuto il classico dubbio della domenica.

Allora comincio con il definire una struttura di questo tipo:

struct object {
	char name[18];
	char second[40];
	unsigned short address;
	unsigned short nfeat;
	unsigned short present;
	unsigned short width;
	unsigned short height;
	unsigned short power;
	struct feature * features;
};

adesso creo due puntatori

struct object * objs_tmp;
struct object * objs;

Il primo verra' allocato in questo modo:

objs_tmp= calloc(sizeof(struct object), 2);

quando avro' reperito il valore di nfeat della struttura potro' inizializzare:

objs_tmp[1].features = calloc(sizeof(struct feature), objs_tmp[1].nfeat);

La dimensione massima di questo array sara' sempre la stessa ed e' data da nfeat.
Cambiera' il numero di valori contenuti, cioe' inizialmente conterra' 20 valori poi 30 e cosi via.

objs_tmp e' di supporto a objs, ossia quando finisco il suo "utilizzo" lo copio in objs.
E qui mi sorge il dubbio.
Per copiarlo utilizzo la funzione memcpy

memcpy(objs, objs_tmp, sizeof(struct object) * 2);

In questo modo la funzione copiera' il numero giusto di byte??
Penso di si perche' avendo una volta definito la grandezza dell'array features la memoria nel heap dovrebbe essere alloccato e fine, quindi poi quando la si copia non ci dovrebbero sorprese indesiderate, ma non sono sicuro al 100% .





ciao e grazie

[YuYevon]

Attenzione all'uso della calloc: il prototipo della funzione è

void * calloc ( size_t num, size_t size );

quindi innanzitutto il primo argomento deve essere il numero di elementi da allocare, e il secondo la dimensione di ciascuno di essi, mentre tu hai fatto il contrario... e poi devi (o almeno è consigliabile) "castare" il puntatore restituito dalla funzione (che è un puntatore a void) nel tipo che ti interessa, quindi nel tuo caso la scrittura corretta sarà:

objs_tmp= (struct object *) calloc(2, sizeof(struct object));

Considerazioni analoghe anche per la seconda allocazione.

Per quanto riguarda la memcpy(), il suo prototipo è

void * memcpy ( void * destination, const void * source, size_t num );

quindi con la chiamata che fai tu sposti un certo numero di byte (pari al doppio della dimensione di una struttura di tipo "struct object") dalla posizione di origine "objs_tmp" a quella di destinazione "objs". Ovviamente, però, per il puntatore di destinazione devi allocare dello spazio in maniera tale da poter copiare i byte senza problemi...

[MItaly]

Non capisco perché tu ti faccia di questi problemi; una volta che hai un puntatore alla struttura allocata nell'heap per metterlo in un altra variabile puntatore ti basta fare

objs = objs_tmp;

.
A meno che tu non voglia creare una copia indipendente della struttura...
P.S.: tra l'altro non capisco neanche perché tu allochi lo spazio per 2 strutture (

objs_tmp= calloc(sizeof(struct object), 2);

): basta lo spazio per una.

objs_tmp= calloc(sizeof(struct object), 1);

.

[nomida]

Oh my god hai proprio ragione!!
La cosa brutta e' che funziona.
Cavoli da un dubbio mi sono ritrovato due errori.

Grazie mille.