Newsgroup: it.comp.lang.c
Titolo: problema prog con calloc

Il programma dovrebbe prendere delle stringhe(max lunghezza 15)  e
memorizzarli in un vettore di stringhe allocato dinamicamente con calloc. Ma
ho sbagliato qualcosa forse nell'uso di calloc con cui non ho molta
dimestichezza.
il programma č:
 #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
void main(void)
{
  int n,i;
  char *p,s[10];
printf("inserisci un numero \n\n");
scanf("%d",&n);fflush(stdin);
p=(char *)calloc(n,15*sizeof(char));
for(i=0;i<n;i++)
{
printf("inserisci stringa\n");
gets(s);fflush(stdin);
 strcpy(&p[i],s);
}
for(i=0;i<n;i++){
 printf("le stringhe sono: %s \n",&p[i]);}
return;
}

 dimestichezza.
Il problema e' che dovresti usare un vettore di stringhe, non un vettore di
caratteri.
(Oppure puoi anche usare un vettore di caratteri, ma poi devi gestirtelo te
come se fosse una matrice)
Quindi aggiornare tutto di conseguenza.
In breve, qualcosa tipo:
-------------------------------
/* Dichiarazione vettore stringhe: e' un puntatore a puntatori di caratteri
*/
char * * string_vect;
/* Allocazione per il vettore di stringhe */
string_vect = (char * *) calloc(n,sizeof(char *)); /* allocazione vettore */
for (i=0;i<n;i++) {
   string_vect[i] = (char *) calloc(15,sizeof(char)); /* allocazione stringa
i-sima */
   lettura_stringa(string_vect[i]);
}
...
/* libero memoria */
for (i=0; i<n; i++) free(string_vect[i]);
free(string_vect);
-------------------------------
Ciao,
Ema

 p=(char *)calloc(n,15*sizeof(char));
Cosě non va bene, devi allocare spazio per un vettore di puntatori, e per
ogni elemento del vettore allocare una stringa di 15 caratteri.
La lista che ti avevo postato non andava bene? ;-)
Cmq ti posto il codice modificato, ora funziona:
La lista che ti avevo postato non andava bene?
Cmq ti posto il codice modificato, ora funziona
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void)
{
 int n,i;
 char **p,s[10];
 printf("inserisci un numero \n\n");
 scanf("%d",&n);fflush(stdin);
 // alloca il vettore
 p=(char **)calloc(n,sizeof(char**));
 // per ogni elemento del vettore
 // alloca lo spazio per 15 caratteri
 for (i = 0; i<n; i++) {
  p[i] = (char*)malloc(15);
 }
 for(i=0;i<n;i++)
 {
  printf("inserisci stringa\n");
  gets(s);fflush(stdin);
  strcpy(p[i],s);
 }
 puts("le stringhe sono:\n");
 for(i=0;i<n;i++){
  puts(p[i]);
  // dealloca la memoria per ogni stringa
  free(p[i]);
 }
 // dealloca la memoria per il vettore
 free(p);
 return 0;
}

 strcpy(&p[i],s);
strcpy(p[i], s);
In sostanza, il tuo programma scritto correttamente diventa:
#include <stdio.h>
#include <stdlib.h>
int main()
{
    char **p, nstr[10];
    int i, n;
    printf("Inserisci un numero: ");
    fgets(nstr, sizeof nstr, stdin);
    n = atoi(nstr);
    p = calloc(n, sizeof(char*));
    for (i=0; i<n; i++)
    {
        p[i] = malloc(50);
        strcpy(p[i], "pippo");
    }
    for (i=0; i<n; i++)
    {
        printf("%d %s\n", i, p[i]);
    }
    return 0;
}
-- 
Andrea Laforgia - a.laforgia(at)
libero.it
"There are three kinds of people in this world; 
 those who are good at maths and those who aren't".

 Andrea Laforgia - a.laforgia(at)
libero.it
Uelà, perdi i colpi? ;-)
Non hai deallocato la memoria ;-p
Ciao

 La lista che ti avevo postato non andava bene? ;-)
Vi ringrazio per la correzione č perfetta,non ci avevo proprio pensato. Cmq
la lista andava bene e che mi serviva qualcosa di indicizzato come un
vettore.

Non hai deallocato la memoria ;-p
Probabilmente è Windows che perde colpi, un sistema operativo serio se
la dealloca da solo.
-- 
Andrea Laforgia - a.laforgia(at)
libero.it
"There are three kinds of people in this world; 


 la dealloca da solo.
Gia' Laforgia non sbaglia mai.....
Ovvio che Windows e molti altri sistemi operativi "deallocano" da soli
quando il processo termina, a quel punto lo spazio viene "ripreso".
Il problema quindi in un programma della forma:
int main(){
     .....
    alloco_memoria();
    .....
    return 0;
}
non si sente, ma se il programma fosse uno di quelli che rimane in
esecuzione parecchie ore e la funzione scritta da te venisse chiamata piu'
volte (senza mai deallocare), beh, fino a che il programma non termina
windows non farebbe nulla! E come puoi immagine potrebbero sorgere vari
problemi!
Immagina ora che il programma sia un web-server che deve rimanere in
esecuzione per mooolto mooolto tempo, ad ogni richiesta dei client viene
eseguita la tua funzione che alloca parecchi bytes ma non li dealloca
mai......
Ecco perche' e' buona pratica deallocare sempre la memoria, anche negli
esempi banali come il tuo. E' una buona abitudine, non prenderla porta a
gravi problemi!
Eisistono anche linguaggi come Java o C# che hanno il garbage collection e
non c'e' bisogno di deallocare, ma qui si parla di C.
Poi, sono d'accordo con te, nel tuo esempio "non serve" (nel vero senso
della parola), ma considero buona pratica farlo e cattiva programmazione non
farlo.
A volte per dare esempi esempi sul NG si omette la deallocazione per
risparmiare tempo, quindi pensavo fosse questo il caso.... Ma invece di
rispondere: "si, era sottointeso, la domanda era su come allocare e non come
deallocare!" o qualche cosa del genere, Laforgia scrive: "Probabilmente è
Windows che perde colpi, un sistema operativo serio se la dealloca da solo."
Gia' Laforgia non sbaglia mai! Le ca**ate le fanno i compilatori ed i
sistemi operativi, ma mai Laforgia.... e se qualche persona come wonderboy
prova soltando di far notare una dimanticanza..... beh.....
Tommy

 la dealloca da solo.
Veramente mi risulta che anche Win se la deallochi da sola la memoria;
magari poi l'OP potrebbe pensare che non sia necessario fare la free della
memoria. Comunque era solo una battuta ;-)
Ciao

 Ciao
Detto il male bisogna anche dire il bene, Andrea è sempre molto tempestivo
nelle sue risposte (non che sia una gara ma mi anticipa spesso) e sempre
preciso. Sicuramente una colonna del NG.
Paolo PAL
P.S. Già che siamo in vena di leggerezze, faccio presente ad Andrea che ho
letto da qualche parte una variante della sua firma molto interessante: Ci
sono 10 tipi di persone, quelli che capiscono il codice binario e quelli che
non lo capiscono :))
Funny.

 preciso. Sicuramente una colonna del NG.
Non ho mai detto il contrario. Quello che dici e' vero.
Putroppo e' il suo carattere... spesso e' maleducato ed arrogante. In questo
frangente e' stato solo arrogante.
E se voleva essere ironico... beh, dato il passato non l'ho colta davvero.
(e non ho notato nessuno smile o altro).
Tommy

 esecuzione per mooolto mooolto tempo, ...
Ci metti la direttiva MaxRequestsPerChild
http://httpd.apache.org/docs-2.0/mod/mpm_common.html#maxrequestsperchild
I memory leakage sono una brutta bestia. :-)
C:\>iao Angelo
P.S. In ogni caso sono d'accordo che la memoria allocata va deallocata
     dal programma.
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

memoria. 
Infatti in un sistema operativo SERIO (ribadisco) non dovrebbe essere
necessario.


Gia' Laforgia non sbaglia mai! 
Purtroppo reinstallando il newsreader ho perso le impostazioni del
kill-file.  E` ora di ripristinarle.  
*plonk*


voleva soltanto salvarsi in extremis :))
Io non ho bisogno di "salvarmi in extremis".  Non ho commesso alcuna
dimenticanza.  La mia risposta č seria.  Ora, se permettete, ignoro
questa ridicola polemica.


 necessario.
Lo so che la memoria viene deallocata automaticamente all'uscita del
programma, ma per lo meno avresti potuto specificare che si trattava di un
caso particolare. L'OP  magari potrebbe vedere un esempio analogo in cui
viene deallocata la memoria, e probabilmente avrebbe potuto pensare che *in
generale* la deallocazione della memoria sia una cosa di cui il
programmatore debba preoccuparsi... e poi magari lui non usa un sistema
operativo serio ;-)
Ciao

 programmatore debba preoccuparsi... e poi magari lui non usa un sistema
Intendevo dire "... non debba preoccuparsi"
Ciao

 *plonk*
Booh, che paura ;-) (piccolo bambino infantile!)
Tommy

 questa ridicola polemica.
Vedi, Paolo, come ti dicevo sara' anche un buon programmatore C, ma ho
l'impressione che come persona invece valga molto meno....
Tommy

 necessario.
Non in un programma cosi' stupido, ma in altri (anche con  un OS serio) e'
fondamentale!
Quindi il tuo esempio e' pessimo (per quanto concordo con te che la maggior
parte degli OS avvino al problema).
Se usciamo dal tuo esempio trivial e andiamo su qualche cosa di piu'
complesso allora, o ti metti a deallocare oppure passi a C# o Java che hanno
un garbage collection!
Tommy

 operativo serio ;-)
Era questo il concetto! Laforgia ha fatto un esempio pessimo, poco
istruttuivo e di cattivo esempio. (poi nel caso specifico non crea problemi)
Tommy

Tommy
Limiteresti i tuoi attacchi personali facendo uso delle email invece
di postare nel ng?
grazie.
Marco.

 di postare nel ng?
Ok, provero' a non scrivere piu' cose che non siano legate al C. (ma
l'arroganza mi da ai nervi).
NO, non scrivero' email alla persona in oggetto.
Tommy