Newsgroup: it.comp.lang.c
Titolo: liste e funzioni - 2

probabilmente il mio post precedente era incomprensibile :), quindi:
ecco il programma che nn fa quello che deve fare:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*questa è la struttura per la lista */
struct elemento {
	char *cognome;
	struct elemento *next;
};
typedef struct elemento ELEM;
void visualizzaLista(ELEM*);
ELEM* cognomi(void);
int main(void)
{
	char file[12];
	int codice;
	ELEM *pStart;
	pStart = cognomi();
	visualizzaLista(pStart);
	return 0;
}
ELEM* cognomi(void)
{
    ELEM *pStart, *pTmp, *pAux;
	int i;
/* qui voglio creare una lista di 2 elementi */
	pStart = malloc(sizeof(ELEM));
	pAux = pStart;
	pTmp = malloc(sizeof(ELEM));
	pAux->next = pTmp;
	pTmp->next = NULL;
	sprintf(pStart->cognome, "aaa");
	sprintf(pTmp->cognome, "bbb");
/* il campo "cognome" del primo elemento è "aaa", quello*/
/* del secondo elemento "bbb"*/
/* forse l'errore è qui?? */
	return pStart;
}
/*questa funzione  mi stampa due volte "bbb", invece non dovrebbe */
void visualizzaLista(ELEM *pStart)
{
	while (pStart != NULL) {
		printf("%s\n", pStart->cognome);
		pStart = pStart->next;
	}
}
/* dove ho sbagliato?? */
/* grazie x l'attenzione */

 typedef struct elemento ELEM;
diceeeevo che non avevano introdotto nuovi tipi di variabili!!!
anGuy

 /* forse l'errore è qui?? */
Ad occhio e croce, scrivi in zone di memoria non allocate (per lo meno, 
a giudicare dal codice che hai postato), il che, generalmente, porta ad 
un segmentation fault. Potrebbe essere interessante indagare perche` il 
tuo compilatore si comporti in modo cosi` fuorviantemente "stabile". 
Nota a margine: visto che devi copiare una stringa in un'altra, perche` 
non usi strcpy()?
-- 
Baci,
Mony

scusate l'intrusione...
pStart->cognome
corrisponde a
(*pStart).cognome ????

 (*pStart).cognome ????
Si`.
-- 
Baci,
Mony

non usi strcpy()?
non è +- la stessa cosa?
grazie



sģ

 	pAux = pStart;
Il membro cognome di ELEM e` un puntatore a carattere, quindi punta ad 
una zona di memoria, quindi qualcuno deve spiegare al compilatore quanto 
grande e` questa zona e chiedergli di trovarle posto... ;)
	pStart->cognome=malloc(how_many_chars+1);
oppure
	struct elemento {
	    char cognome[A_CONSTANT_VALUE];
	    struct elemento *next;
	};
-- 
Baci,
Mony

	};
già, non ci avevo pensato! grazie ancora!

 non č +- la stessa cosa?
Quasi. sprintf() e` una funzione variadica [1] e controlla la stringa di 
formato in un fantasmagorico switch per sapere cosa stampare nella 
stringa di destinazione, mentre strcpy() copia caratteri finche` non 
incontra il terminatore. E` ipotizzabile che la seconda abbia 
prestazioni migliori, come un brutale benchmark del tipo:
<code>
	#include <stdio.h>
	#include <string.h>
	#include <time.h>
	int
	main(void)
	{
           time_t start,end;
           int i;
           char str[13];
           time(&start);
           for(i=0;i<5000000;i++) sprintf(str,"Hello world!");
           time(&end);
           printf("sprintf(): %d\n",end-start);
           time(&start);
           for(i=0;i<5000000;i++) strcpy(str,"Hello world!");
           time(&end);
           printf("strcpy(): %d\n",end-start);
           return 0;
	}
</code>
potrebbe rozzamente giustificare:
	run  sprintf()  strcpy()
         ---  ---------  --------
	  1          5         0
	  2          5         1
	  3          5         0
	  4          5         1
	  5          5         1
	  6          4         1
	  7          5         1
           8          5         1
           9          5         1
          10          5         0
preso, ovviamente, con tutte le molle del caso...
[1] Con numero di argomenti variabili, il che implica l'accesso allo 
stack etc...
-- 
Baci,
Mony