[C] Segmentation Fault

[C3ls1us]

Le opzioni sono due, o sono fuso, o c'è qualcosa che non capisco...parola al codice...

Prima:

Main:
int main(void)
{
>>struct tree a;
>>int i;

>>for(i=0;i<5;i++)
>>>>push("pippo",i,&a.high);

>>scan(a.high);
}

Prototipi:
bool push(char *start,int x,pnode *pt);
void scan(pnode pt);
//La funzione push NON utilizza il parametro stringa di char, è una funzione di push su una lista.
//Scorre la lista e stampa con printf.

bool push(char *start,int x,pnode *pt)
{printf("Check\n");
>>if((*pt)==NULL)
>>{
>>>>*pt=(pnode)malloc(sizeof(node));
>>>>>>if(*pt==NULL) return FALSE;

>>(*pt)->x=x;
(...)

OutPut:
mattia@mattia-nb:~/c/pony$ gcc main.c
mattia@mattia-nb:~/c/pony$ ./a.out
>> 0 >> 1 >> 2 >> 3 >> 4

TDD:
struct tree è una struttura che contiene vari elementi, fra questi *high, puntatore a lista semplice.

Dopo:

Main:
int main(void)
{
>>struct tree a;
>>int i;
>>char stringa[N];
>>scanf("%s",stringa);

>>for(i=0;i<5;i++)
>>>>push("pippo",i,&a.high);
>>scan(a.high);
}
OutPut:
mattia@mattia-nb:~/c/pony$ gcc main.c
mattia@mattia-nb:~/c/pony$ ./a.out
pluto
Check
Segmentation fault

NON ho cambiato null'altro...help!!!
Ho provato anche con fflush(stdin); ma nulla...

mattia@mattia-nb:~/c/pony$ ./a.out
Check
Check
Check
Check
Check
>> 0 >> 1 >> 2 >> 3 >> 4
Questo è l'output che si ottiene togliendo la dichiarazione della variabile e lo scanf.

[C3ls1us]

Ho risolto con l'allocazione dinamica. Però qualcuno ha idea di dove si trovi il problema?
A parte il fatto che per allocare una stringa di char bisogna fare dei giri infiniti...

int main(void)
{
struct tree a;
int i;
struct elem *item;
item=(elem*)malloc(sizeof(item));
item->start=(char*)malloc(sizeof(char)*N);
item->end=(char*)malloc(sizeof(char)*N);
scanf("%s",item->start);
scanf("%s",item->end);

for(i=0;i<5;i++)
push(i,&a.high);
scan(a.high);
}

[||ElChE||88]

Quanto grosso è N?

[C3ls1us]

Non mi sembra proibitivo...

/*header.h*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "timeanddistance.h"
#define N 30
#define TRUE (1==1)
#define FALSE (!TRUE)

(...TDD...)

[!k-0t1c!]

Se è bastato allocare dinamicamente la memoria allora avevi un solo problema, e anche piuttosto banale:
supponi di usare sempre lo stesso buffer, definito come

char stringa[N];

all'interno della tua funzione. A parte il limite imposto ad N dal fatto che N bytes saranno allocati sullo stack, il problema principale è che quando assegni a item->start o item->end o un qualsiasi altro puntatore il valore di stringa, stai assegnando in realtà l'indirizzo sullo stack al quale stringa si trova. A parte il fatto che non stai facendo quel che vorresti, perché alla fine item->start e item->end appena riutilizzi stringa saranno persi, l'altro problema è che andando avanti nell'esecuzione del codice non è affatto detto che l'indirizzo a cui era allocata la variabile stringa sia ancora leggibile (e comunque non sai che caratteri conterrà), così quanto passi un puntatore a quell'indirizzo vai in segfault.

[C3ls1us]

Scusami, non credo di aver capito.
Non ho allocato prima un array "char stringa[N]" per poi farci puntare due puntatori *char.

char stringa[N];
char *s,...;
s=&(*stringa);

Ma ho allocato degli array con allocazione dinamica, quindi equivalente!
char stringa[N] == char *stringa; stringa=(char*)malloc(sizeof(char)*N);

No?! Dove stà l'inghippo? Perchè allocare una variabile senza neppure utilizzarla fa segmentare una funzione completamente indipendente?

/*main.c*/
#include "header.h"

void scan(pnode pt)
{
	for(;pt!=NULL;pt=pt->next)
		printf(">> %d ",pt->x);
	printf("\n");
}
bool push(int x,pnode *pt)
{
	if((*pt)==NULL)
	{
		*pt=(pnode)malloc(sizeof(node));
			if(*pt==NULL) return FALSE;
			
		(*pt)->x=x;
	}
	else
	{
		pnode aux;
		aux=(*pt);
		
		while(aux->next!=NULL)
			aux=aux->next;
		
		aux->next=(pnode)malloc(sizeof(node));
		aux=aux->next;
			if(aux==NULL) return FALSE;
		
		aux->x=x;
	}
	return TRUE;
}

int main(void)
{
	struct tree a;
	int i;
	struct elem *item;
	item=(elem*)malloc(sizeof(item));
	item->start=(char*)malloc(sizeof(char)*N);
	item->end=(char*)malloc(sizeof(char)*N);
	scanf("%s",item->start);
	scanf("%s",item->end);
		
	for(i=0;i<5;i++)
		push(i,&a.high);
	scan(a.high);
}
====================================================
/*header.h*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "timeanddistance.h"
#define N 30
#define TRUE (1==1)
#define FALSE (!TRUE)

/*
push
pop
load
set rush
is_node_empty
stampa_perc
time
minore distanza
*/

typedef struct elem
{
	int p;
	char *start;
	char *end;
}elem;
typedef struct lista
{
	int x;
	struct lista *next;
}node,*pnode;

typedef char bool;

typedef struct tree
{
	node *high;
	node *low;
	node *consegne;
	node *percorso;
	struct tm time;
	int ore_lavorative;
	int start_hour;
	char start_place[N];
}pony;

/*timeanddistance contiene solo dei prototipi di funzione non ancora utilizzati.*/

[!k-0t1c!]

Mi spiego meglio: se la versione con allocazione dinamica funziona correttamente allora l'unico problema delle precedenti versioni è quello che ho descritto nel mio scorso post.
Nota che un altro modo di risolvere il problema è definire:

typedef struct elem
{
	int p;
	char start[N];
	char end[N];
}elem;

in maniera tale che quando chiamerai free sarà deallocata tutta la struttura, stringhe comprese. Facendo così eviti inoltre la malloc per ogni start ed end di elem. Ovviamente per N molto grandi non è una buona soluzione, ma diversamente è la cosa più comoda.

[C3ls1us]

Si, la struct elem era già prevista nel mio tipo di dato. Solo vorrei capire cosa non gli garba dichiarando una stringa di caratteri in maniera automatica piuttosto che dinamica.
Per evitare lo stesso problema in futuro...!

[C3ls1us]

Me stupido!
Ho incasinato fra puntatori e array veri e propri. Non allocando sempre e mancando di inizializzare alcuni puntatori a NULL prima di passarli a funzioni.

Grazie della disponibilità. Non posto ulteriormente per evitare di intasare...!
Grazie!!!
(Si può chiudere.)