Newsgroup: it.comp.lang.c
Titolo: segmentation fault che proprio non mi spiego...

Il programma esegue la ricerca in ampiezza su un albero.
I dati dell'albero sono su un file nel formato:
TOT //numero totale di vertici
*K0 //numero identificativo del vertice
A0  //numero di vertici adiacenti al vertice K0
n01 //numero identificativo del primo vertice adiacente a k0
n02 //numero identificativo del secondo vertice adiacente a K0
..
*K1 //stessa cosa ripetuta TOT volte...
A1
n11
n12
..
Ho implementato il tutto con le liste di adiacenza, usando la seguente
struttura dati:
typedef struct _ADJ {
	int	  			v_name;
	int				weight;
	struct _ADJ			*next;
}ADJ;
typedef struct _VERTEX{
	int			name;
	unsigned int 		nadj;
	ADJ			*adjlist;
	struct _VERTEX		*next;
}VERTEX;
il programma funziona, esegue la visita e mirestituisce il vettore che
contiene l'ordine in cui ha visitato i vertici, lo stampa, arriva
a stampare anche la parola "PAPETTI" che è l'ultima cosa prima del
return 0..
poi da segmentation fault...
se prima del return 0 gli metto un _exit(0) funziona.
se metto un exit(0) no.
Qualcuno saprebbe cortesemente spiegarmi dove è l'errore?
grazie mille.
int main(int argc, char *argv[]){
	int i, *vect, hm, k;
	/*clear_screen();*/
	VERTEX *graph, *head;
	ADJ *iter;
	FILE *fin;
	fin=open_file(argv[1], "r");
	hm=build_graph(fin, &graph, false);
	head=graph;
	iter=graph->adjlist;
	vect=breadth_first_search(head, 0, hm);
	for(i=0; i<hm; i++)
		printf("%d ", vect[i]);
	if(fin)
		fclose(fin);
	printf("PAPETTI\n");
	/*_exit(0); se tolgo questo commento funziona, 
			altrimenti segmentation	fault*/
return 0;
};
/*******************************************/
int build_graph(FILE *fin, VERTEX **graph_out, BOOLEAN weight){
	int hm, i, k, adj;
	ADJ *list=NULL, *head_l=NULL;
	VERTEX *graph=NULL, *head_g=NULL;
	hm=read_iff(fin);
	for(i=0; i<hm; i++){
		head_g=(VERTEX *)my_malloc(sizeof(VERTEX));
		k=fgetc(fin);
		head_g->name=read_iff(fin);
		adj=head_g->nadj=read_iff(fin);
		for(k=0; k<adj; k++){
			list=(ADJ *)my_malloc(sizeof(ADJ));
			list->v_name=read_iff(fin);
			if(weight)
				list->weight=read_iff(fin);
			else
				list->weight=1;
			list->next=head_l;
			head_l=list;
		}
		head_g->adjlist=head_l;
		head_g->next=graph;
		graph=head_g;
	}
	*graph_out=graph;
return hm;
}
/****************************************************/
int *breadth_first_search(VERTEX *graph, int first_node, int hm){
	int *distance, *predecessor, i, current_node, *visited, k=0;
	int *node_color, g, *queue, head=0, tail=0;
	VERTEX *graph_saved, *graph_adj; ADJ *adjlist_saved;
	graph_saved=graph;
	distance=(int *)my_malloc(sizeof(int)*hm); predecessor=(int
	*)my_malloc(sizeof(int)*hm); visited=(int *)my_malloc(sizeof(int)*hm);
	node_color=(int *)my_malloc(sizeof(int)*hm); queue=(int
	*)my_malloc(sizeof(int)*hm); for(i=0; i<hm; i++){
		node_color[i]=white;
		distance[i]=INT_MAX;
		predecessor[i]=NIL;
	}
	node_color[first_node]=gray;
	distance[first_node]=0;
	insert_in_queue(queue, first_node, head, &tail, hm);
	while((current_node=extract_from_queue(queue, &head, tail, hm))!=NIL){
		pause(true);
		graph=graph_saved;
		i=0;
		printf("\n");
		printf("\nCurrent node is %d\n", current_node);
		while(graph->name!=current_node)
			graph=graph->next;
		printf("NAME: %d\n", graph->name);
		printf("Nadj: %d\nAdjlist: ", graph->nadj); for(i=0; i<graph->nadj;
		i++){
			printf("%d ", graph->adjlist->v_name);
			if(node_color[graph->adjlist->v_name]==white){
				node_color[graph->adjlist->v_name]=gray;
				visited[++k]=graph->adjlist->v_name;
				distance[graph->adjlist->v_name]=distance[current_node]+1;
				predecessor[graph->adjlist->v_name]=current_node;
				insert_in_queue(queue, graph->adjlist->v_name, head, &tail, hm);
			}
			graph->adjlist=graph->adjlist->next;
		}
		printf("\n");
		node_color[current_node]=black;
	}
	free(node_color);
	free(predecessor);
	free(distance);
	free(queue);
return visited;
};
/********************************************************/
int insert_in_queue ( int *vect, int node, int head, int *tail, int dim){
		if ( (head) == ( (*tail)%dim +1) )
			return(my_error(6));/*restituisce NIL=-1*/
		vect[(*tail)++] = node;
		if ((*tail)== dim)
			(*tail) = 0;
return 0;
}
/**************************************************/
int extract_from_queue ( int *vect, int *head, int tail, int dim){
	int node;
	printf ("\nInside 'extract_from_queue':\nhead: %d\ntail: %d\n",*head, tail);
		if ( (tail) == (*head) )
			return(my_error(7));/*restituisce NIL=-1*/
		node = vect[(*head)++];
		if ((*head) == dim)
			(*head) = 0;
return (node);
}
/****************************************************/
int read_iff(FILE *fin){
	char *num;
	fgets(num, MAX_LEN_LINE, fin);
return atoi(num);
};
/***************************************************/
void *my_malloc(size_t size){
	void *space;
	if(!(space=malloc(size)))
		exit(my_error(2));
return space;
};
/****************************************************/

 Il programma esegue la ricerca in ampiezza su un albero.
[cut]
Prova a controllare l'output di valgrind
(valgrind --skin=memcheck -v --leak-check=yes --show-reachable=yes
./nometuoprogramma)
http://valgrind.kde.org/
Ciao
-- 
"No need for anything but music
Music's the reason why I know time still exists"  Elisa
Shannara

grazie del consiglio, sono riuscito ad individuare l'errore: è nella
funzione 
int read_iff(FILE *fin){
	char *num;
	fgets(num, MAX_LEN_LINE, fin);
return atoi(num);
}
lo scopo della funzione è leggere un intero da file, ma non capisco
dove sia l' errore; l'output di valgrind è il seguente:
==3743== Use of uninitialised value of size 4
==3743==    at 0x4029CC9C: (within /lib/i686/
libc-2.3.2.so
)
==3743==    by 0x4029CBD1: (within /lib/i686/
libc-2.3.2.so
)
==3743==    by 0x4029BB9D: (within /lib/i686/
libc-2.3.2.so
)
==3743==    by 0x8048F5B: read_iff (in /home/papetti/Documents/Poker/
							/modulare/prova)
e poi lo ripete per ogni funzione in cui richiamo read_iff.
al dilà della funzione in se, che non ci va molto a scriverne una
differente, vorrei capire perchè è sbagliata, qualcuno sa illuminarmi?
grazie

 dove sia l' errore; l'output di valgrind è il seguente:
L'errore e' che leggi nel buffer char *num che non hai allocato...
La fgets presume che tu abbia allocato (staticamente o
dinamicamente, a tuo piacimento) abbastanza memoria per memorizzare
la linea da leggere dal file.
Attualmente, non avendo riservato memoria per *num,
stai leggendo in un punto qualunque della memoria...
ciao,
g.

In effetti...
grazie mille, era proprio quello, ora funziona..
ciao e ancora grazie