Newsgroup: it.comp.lang.c
Titolo: errore su una lista

xchè mi dà errore?
nn capisco provo cosa va passato e come alla funzione che prende un 
valore e lo inserisce alla lista dopo l'ultimo già inserito
#include <stdio.h>
#include <stdlib.h>
struct fanculo {
	int n;
	struct fanculo *next;
};
struct fanculo *crea();
struct fanculo *aggiungi(struct fanculo *p, int val);
main()
{
	struct fanculo *listaPtr;
	listaPtr = crea();
	aggiungi(struct listaPtr *p, 5);
}
struct fanculo *crea()
{
	int size;
	struct fanculo *p;
	size = sizeof(struct fanculo);
	p = malloc(size);
 
	p->n = 0;
	p->next = NULL;
}
struct fanculo *aggiungi(struct fanculo *p, int val) {
 
	int size;
	struct fanculo *p, *paus;
	size = sizeof(struct fanculo);
	paus->next = malloc(size);
	paus = paus->next;
 
	paus->n = val;
	paus->next = NULL;
}

     paus->next = malloc(size);
qui stai usando un puntatore (paus->next)
ma paus non e' stato definito, quindi punti a
caso nella memoria.
In ogni caso non mi sembra che tu sia sforzato
molto a provare ad implementare la cosa:
nel tuo codice ridichiari il parametro *p
che viene passato e poi non lo usi neanche ...
Per aggiungere in testa alla lista
devi semplicemente:
struct fanculo *aggiungi(struct fanculo *p, int val)
{
// 1) allocare un nuovo record:
struct fanculo *paus;
paus = malloc(sizeof(struct fanculo));
// 2) settare i campi
paus->n=val;
paus->next=p;
// 3) ritornare il puntatore alla nuova lista
return paus;
}
Se invece vuoi aggiungere l'elemento in coda devi
scorrere la lista prima di aggiungere l'elemento.
ciao,
g.

 paus->next=p;
grazie
ma xchp su
paus->next=p; ??
nn devo puntarlo a NULL?
ho visto che avevo dimenticato il malloc


se vuoi che quello aggiunto sia il primo elemento della lista
allungata
dovrai ben puntare il suo puntatore
al resto della lista !
Se lo metti uguale a null hai semplicemente
perso ogni riferimento alla lista
vecchia...
Scusa, la funzione e' cortissima.
Fatti un disegnino ed "eseguila" a mano
sulla carta se vuoi toglierti ogni dubbio.
ciao,
g.

ok ma a te funziona?
ok provo sul foglio

 ok provo sul foglio
Hai sbagliato anche la funzione crea() ...
dichiari che deve ritornare un puntatore e
poi non ritorni nulla....
Ovvio che poi il programma non funziona.
Comunque, per snellire il programma ti consiglio
l'uso del typedef :
se scrivi
struct fanculo {
     int n;
     struct fanculo *next;
};
typedef struct fanculo elem;
dopo puoi sempre usare elem invece
di struct fanculo...
ciao,
g.

ok grazi di tutti i suggerimenti..ti faccio sapere se ci riesco

cioč dovrei mettere un
return *p;
?
che mi puo' essere utile per la stampa?


a parte che per la stampa, ti e' utile perche'
altrimenti non hai NESSUN modo per accedere
al record che hai allocato...
penso che dovrebbe essere
return p;
ciao
g.

l'ho sistemata un po'....xo' mi dà un segmentation
#include <stdio.h>
#include <stdlib.h>
struct fanculo {
	int n;
	struct fanculo *next;
};
typedef struct fanculo fan;
fan *crea();
fan *aggiungi(fan *p, int val);
fan stampa(fan *p);
main()
{
	fan *listaPtr, *p;
	listaPtr = crea();
	aggiungi(listaPtr, 5);
	aggiungi(listaPtr, 9);
	aggiungi(listaPtr, 1);
	stampa(listaPtr);
 
}
fan *crea()
{
	int size;
	fan *p, *paus;
	size = sizeof(fan);
	p = malloc(size);
	paus = p;
	p->n = 0;
	p->next = paus;
	return p;
}
fan *aggiungi(fan *p, int val) {
 
	int size;
	struct fanculo *paus;
	size = sizeof(fan);
	paus = malloc(size);
 
	paus->n = val;
	paus = paus->next;
	paus->next = NULL;
}
fan stampa(fan *p) {
	while(p!=NULL) {
		printf("%d -> ", p->n);
		p = p->next;
	}
}

ci sono riuscito!
ma la stampa è questa
bash-2.05b$ ./fanculo
5 -> 9 -> 1 -> 0 -> NULL
ma in teoria a me servirebbe questa stampa
0 -> 5 -> 9 -> 1 -> NULL
cmq grazie ho capito molto d+...:-)
#include <stdio.h>
#include <stdlib.h>
struct fanculo {
	int n;
	struct fanculo *next;
};
typedef struct fanculo fan;
fan *crea();
fan *aggiungi(fan *p, int val);
fan stampa(fan *p);
main()
{
	fan *listaPtr, *p;
	listaPtr = crea();
	aggiungi(listaPtr, 5);
	aggiungi(listaPtr, 9);
	aggiungi(listaPtr, 1);
	stampa(listaPtr);
 
}
fan *crea()
{
	int size;
	fan *p, *paus;
	size = sizeof(fan);
	p = malloc(size);
	paus = p;
	p->n = 0;
	p->next = paus;
	paus->next = NULL;
	return (p);
}
fan *aggiungi(fan *p, int val) {
 
	int size;
	struct fanculo *paus;
	size = sizeof(fan);
	paus->next = malloc(size);
 
	paus->n = val;
	paus = paus->next;
	paus->next = NULL;
	return (p);
 
	}
fan stampa(fan *p) {
	while(p!=NULL) {
		printf("%d -> ", p->n);
		p = p->next;
	}
	printf ("NULL\n");
}

 }
questa funzione potrebbe anche andare, ma
NON ritorna un fan come tu invece dichiari.
ciao,
g.

a me cosě funziona, solo che il primo elemento dovrebbe essere 0 invece 
lo sbatte alla fine. ho provato col tuo codice n.2 ma nn riuscivo a 
aggiungere altri elementi, mi dava solo
0 -> NULL
#include <stdio.h>
#include <stdlib.h>
struct fanculo {
	int n;
	struct fanculo *next;
};
typedef struct fanculo fan;
fan *crea();
fan *aggiungi(fan *p, int val);
fan stampa(fan *p);
main()
{
	fan *listaPtr, *p;
	listaPtr = crea();
	aggiungi(listaPtr, 5);
	aggiungi(listaPtr, 9);
	aggiungi(listaPtr, 1);
	stampa(listaPtr);
 
}
fan *crea()
{
	int size;
	fan *p, *paus;
	size = sizeof(fan);
	p = malloc(size);
	paus = p;
	p->n = 0;
	paus->next = NULL;
	return (p);
}
fan *aggiungi(fan *p, int val) {
 
	int size;
	struct fanculo *paus;
	size = sizeof(fan);
	paus->next = malloc(size);
 
	paus->n = val;
	paus = paus->next;
	paus->next = NULL;
	return (p);
 
	}
fan stampa(fan *p) {
	while(p!=NULL) {
		printf("%d -> ", p->n);
		p = p->next;
	}


     }
Come ti ho gia' detto svariate volte questa funzione e'
errata. Ti avevo anche postato il codice giusto. Non
so se ti rendi conto che passi il puntatore p alla lista
corrente e poi non usi la varibile p in nessuna linea del codice,
a parte ritornarla.... come puoi pretendere ragionevolmente
che possa funzionare ???
Siccome comincio a nutrire il forte sospetto che tu mi
stia prendendo per il naso, ti copio sotto una versione
funzionante e corretta del tuo codice, dopo di che chiudo
irrimediabilmente la comunicazione.
ciao (addio),g.
---------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
struct fanculo {
     int n;
     struct fanculo *next;
};
typedef struct fanculo fan;
fan *crea()
{
     fan *p;
     p = malloc(sizeof(fan));
     p->n = 0;
     p->next = NULL;
     return p;
}
fan *aggiungi(fan *p, int val)
{
     fan  *newp;
     newp = malloc(sizeof(fan));
     newp->n = val;
     newp->next = p;
     return newp;
}
void stampa(fan *p)
{
     while(p!=NULL) {
         printf("%d -> ", p->n);
         p = p->next;
     }
     printf ("NULL\n");
}
int main()
{
     fan *listaPtr;
     listaPtr = crea();
     listaPtr = aggiungi(listaPtr, 5);
     listaPtr = aggiungi(listaPtr, 9);
     listaPtr = aggiungi(listaPtr, 1);
     stampa(listaPtr);
     return 0;
}
---------------------------------------------------

grazie ho visto che il tuo funziona perfettamente e ora lo studierò per 
bene. cmq nn ne nel mio interesse prenderti in giro per nessuna ragione.
posso chiederti ulteriori chiarimenti se nn capisco qualcosa?
grazie ancora della pazienza

 valore e lo inserisce alla lista dopo l'ultimo già inserito
Non ho  intenzione di leggere questo  thread per *ovvi* motivi  ... solo
una domanda; ma la news che trovi su:
http://snipurl.com/fx_list
l'hai mai letta? ;)
Ciao.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

si grazi l'avevo letta ma c'erano troppo istruzione che nn capivo