[C]Allocazione dinamica

[MEMon]

Mettiamo che ho la mia struttura definita con typedef Dati.
Se io voglio allocare dinamicamente una parte di memoria riservata ad un array contenente 10 strutture di questo tipo va bene fare così?


Dati *mem,dato;
mem=(Dati *)malloc(sizeof(Dati)*10);


Nel caso andasse bene seguitate a leggere :D

Mettiamo che ho scritto in una pipe 10 strutture Dati

write(apipe[1],&dato,sizeof(Dati)); //per 10 volte


Se ora volesse leggere il contenuto della pipe, e costruire per bene il mio array di Dati puntato da mem come devo procedere?
Va bene così?

int i,retvalue=0;
for(i=0;retvalue!=sizeof(Dati);i++){
retvalue=read(apipe[0],(mem+i),sizeof(Dati));
}

C'è qualcosa che non quadra di sicuro...

edit: la struttura è questa:

struct Dati{
int id;
char *string;
};

Mi sembra strano che posso fare un sizeof(Dati) considerando che contiene un campo che ha una dimensione non precisata, mi riferisco al puntatore a carattere che uso per le stringhe...

[MEMon]

Ho provato anche così per leggere le strutture dalla pipe

read(apipe[0],mem,sizeof(Dati));
printf("%s", (*mem).string);


Sicuramente mem ha spazio a sufficenza per leggere almeno una struttura, ma non capisco come mai il printf mi stampa dei numeri(una locazione di memoria penso)

edit:stampava numeri perchè avevo messo un %d al posto di %s
Ora stampa una stringa a caso...

[MEMon]

Ho provato a scrivere la struttura in questo modo

struct Dati{
int id;
char string[3];
}

//nel main
typedef struc Dati Dati
Dati dato;
char string1[3];


Ma quando vado a fare un
string1[0]='a';
string1[1]='b';
string1[2]='\0';
dato.string=string1;
dice che sono di tipo incompatibile...eppure sono entrambi array di caratteri no e per di + della setssa dimensione!!

[andbin]

int i,retvalue=0;
for(i=0;retvalue!=sizeof(Dati);i++){
retvalue=read(apipe[0],(mem+i),sizeof(Dati));
}No, così cicla solo se retvalue è diverso dalla quantità corretta! Quindi la prima lettura la fa, le altre no.

Ti conviene fare:
int i, retvalue = sizeof(Dati);

for (i = 0; i < 10 && retvalue == sizeof(Dati); i++) {
retvalue = read (apipe[0], &mem[i], sizeof(Dati));
}


P.S. non usare il quote per mettere il codice ... altrimenti complichi la vita a chi risponde.

[MEMon]

Ecco te hai usato nel read &mem[i], mi potresti spiegare come mai?

ps.si scusami, mi sa che sono un po' cotto, pensa che stavo pure pensando al come mai non mi rimaneva più l'indentazione nel codice...ecco usavo i quote...

[MEMon]

comunque non funziona, non termina neppure il programma, guarda te lo incollo qui pari pari( con Code stavolta :D)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#define PERM 0644
struct info{
int id;
char *string;
};

main(int argc, char **argv){
int i,pid,fl,exit_pid,status,retvalue=0;
typedef struct info Dati;
Dati *mem,blocco;
int fod;
int apipe[2];
char string[3];
char ch;

if(argc<=1){
puts("E' necessario almeno un parametro");
exit(-1);
}
mem=(Dati *)malloc(sizeof(Dati)*(argc-1));
if(pipe(apipe)<0){
perror("Errore creazione della pipe");
exit(-1);
}
for(i=1;i<argc;i++){
pid=fork();
if(pid<0){
perror("Errore creazione processo figlio");
exit(-1);
}
else if(pid==0){
if((fod=open(argv[i],O_RDONLY))<0){
perror("Errore creazione file");
exit(-1);
}
fl=lseek(fod,0L,2);
if(fl>=2){
lseek(fod,1L,0);
read(fod,&ch,1);
string[0]=ch;
lseek(fod,(fl-2),0);
read(fod,&ch,1);
string[1]=ch;
string[2]='\0';
blocco.id=i;
blocco.string=string;
printf("%s\n", blocco.string);
write(apipe[1],&blocco,sizeof(Dati));
}
exit(0);
}
}
while((exit_pid=wait(&status))!=-1){
printf("Terminato il processo figlio PID=%d\n",exit_pid);
}
retvalue=sizeof(Dati);
for(i=0;i<10&&retvalue==sizeof(Dati);i++){
retvalue=read(apipe[0],&mem[i],sizeof(Dati));
//printf("%s",mem[i].string);
}
}

[andbin]

Ecco te hai usato nel read &mem[i], mi potresti spiegare come mai?Perché &mem[i] e mem+i sono la stessa cosa.

Quando il compilatore incontra una espressione E1[E2], la converte in *(E1+E2) grazie all'aritmetica dei puntatori.

Ne consegue che applicando & ad entrambi si ha che &E1[E2] diventa (E1+E2). (& e * si contrappongono).

Tra l'altro, se noti, si ha una somma, che è commutativa, quindi sarebbe perfettamente legale fare ad esempio 5[mem] invece di mem[5] oppure &i[mem] invece di &mem[i].
(ma non fatelo mai!! :D )

[MEMon]

capito, cmq nel codice che ti ho postato noti dei gravi errori?Mi sai dire cosa sbaglio?

Se lo vuoi provare ti dico cosa fa, in pratica gli devi passare come parametri dei nomi di file(almeno uno) e per ogni file crea un figlio che legge dal file il primo e penultimo carattere(il file deve avere almeno 2 caratteri), e crea una struttura dove salva l'indice del file e la stringa dei due caratteri letti.
Questa struttura deve essere passata al padre.

A me manca l'ultimo pezzo...il padre non riceve la struttura correttamente... :cry:

[MEMon]

Sembra bloccarsi in
retvalue=read(apipe[0],&mem[i],sizeof(Dati));

[andbin]

Sembra bloccarsi in
retvalue=read(apipe[0],&mem[i],sizeof(Dati));In quella pagina che ho linkato dice:

A pipe or FIFO has to be open at both ends simultaneously. If you read from a pipe or FIFO file that doesn't have any processes writing to it (perhaps because they have all closed the file, or exited), the read returns end-of-file.

Credo che sia appunto perché i figli sono già terminati quando fai la read.

[MEMon]

No perchè ho provato con una stringa e funziona.
se stampo il sizeof(*mem) da un numero troppo piccolo per poter contenere 10 strutture...

[andbin]

se stampo il sizeof(*mem) da un numero troppo piccolo per poter contenere 10 strutture...sizeof(*mem) stampa la dimensione in byte di 1 struttura e basta. Sempre.
Infatti l'unica cosa che sa è che quanto puntato da mem è una struttura Dati.

[MEMon]

ma quindi te non vedi errori?