array di struttura
Larry
mi sono imbattuto in questa linea di codice per me incomprensibile e
volevo sapere se per caso rendeva una variabile un array di una struttura
gi� predefinita:
sb = (WAVEHDR**) malloc(sizeof(WAVEHDR**) * system_buf_num);
Larry
"Tetsuya" <i...@noi.com> ha scritto nel messaggio
news:4b2e2b2a$0$1107$4faf...@reader4.news.tin.it...
> Qui stai mallocando un puntatore a puntatore a WAVEHDR (che presumo sia
> una struttura relativa all'header di un wav). Vista cos� potrebbe essere
> usata ad esempio come "array" (perdonatemi) dinamico di puntatori a questa
> struttura. E quanti ne stai allocando? system_buf_num.
> Avrai sb[i] (con i che va da 0 a system_buf_num-1) e ogni elemento
> dell'array � un puntatore a WAVEHDR.
Ti ringrazio. Nella struttura WAVEHDR ho un campo "lpdata" di tipo LPSTR.
trovo di difficile comprensione questa riga:
sb[i]->lpData = (LPBYTE) malloc(system_buf_len);
perch� viene usato il (LPBYTE) ??
grazie
Andrea Laforgia
> sb = (WAVEHDR**) malloc(sizeof(WAVEHDR**) * system_buf_num);
A rigor di logica, questa istruzione non è valida, nel senso che
dovrebbe essere sizeof(WAVEHDR*) - un solo asterisco.
Nei fatti funziona solo perché le dimensioni dei puntatori sono
evidentemente uguali, a prescindere dal tipo puntato.
Giacomo
Puoi spiegare meglio il tuo punto di vista?
Il tuo appunto l'avrei trovato sensato nel caso contrario, ovvero
avendo:
T ** x = (T**) malloc(sizeof(T*) * k);
avrei fatto notare come l'istruzione funzioni solo perché sizeof(T*)
== sizeof(T**), ma non ci trovo niente di sbagliato/invalido
nell'usare malloc nella forma
T x = (T)malloc(sizeof(T)*k)
per ogni T (magari eccetto 'char' dove sizeof() lo considererei
ridondantemente errato)
GM
> T x = (T)malloc(sizeof(T)*k)
malloc ritorna T* non T
Andrea Laforgia
> Puoi spiegare meglio il tuo punto di vista?
Non è un punto di vista. E' una constatazione.
Se hai:
T* p;
L'allocazione corretta per 10 T è:
p = ( T* ) malloc( sizeof( T ) * 10 );
Perché tu allochi memoria per 10 T, quindi devi considerare la
grandezza del valore puntato, non per dieci puntatori a T.
Se hai T con sizeof(T) > sizeof(T*), infatti, quell'istruzione può
essere molto pericolosa.
Larry
> Probabilmente sia LPSTR (che la butto sempre l�, mi sembra una dicitura
> windows-like per puntatore a stringa) che LPBYTE (puntatore a byte?)
> saranno puntatori a char, quindi punteranno allo stesso tipo, il
> compilatore non si incazza pi� di tanto, e dovrebbe funzionare
> ugualmente...ma la sto buttando l� eh.
Perfetto. Stavo cercando di costruire un sistema di buffers da passare poi a
funzioni waveIn. Questo � il codice:
#define system_buf_len 4096
int i=0;
int num_buff = 5;
WAVEHDR *buffer = (WAVEHDR *) malloc(sizeof(WAVEHDR)*num_buff);
for (i=0; i<num_buff; i++)
{
buffer[i].lpData = (char *) malloc(system_buf_len);
buffer[i].dwBufferLength = system_buf_len;
buffer[i].dwFlags = 0;
waveInPrepareHeader(phvi, &buffer[i], sizeof(WAVEHDR));
waveInAddBuffer(phvi, &buffer[i], sizeof(WAVEHDR));
}
credi che sia corretto un'approccio del genere?
grazie