Lettura da file con allocazione in una lista

[vegetablu]

Salve a tutti,
ho un problema con un programma che gestisce un magazino di ricambi. Io per adesso lo sto provando solo con interi, perchè ancora non ho assimilato bene la funzione che permette di scrivere dentro un'allocazione di memoria, una stringa. Se non sbaglio si chiama strcpy questa funzione.
Il problema per adesso sta nella lettura degli interi. Per la scrittura, ecc. ci siamo perfettamente, ma per la lettura mi da sempre un errore riguardante la segmentazione.
Potreste aiutarmi???

Io sto usando il linguaggio C su piattaforma UNIX (Linux Ubuntu).
Vi ringrazio anticipatamente.


Ecco il codice che ho scritto:

#include <stdio.h>
#include <stdlib.h>
struct articolo{ int num;
struct articolo *next; };
typedef struct articolo nodo;
nodo *cons(nodo *start, nodo *p);
char menu();
void stampa(nodo *start, nodo *p);
nodo *delete(nodo *start, nodo *p);
nodo *leggi(nodo *start, nodo *p);
void scrivi(nodo *start, nodo *p);

main(int argc, char **argv)
{
char sc;
nodo *start, *p, *punt;

start=(nodo *)malloc(sizeof(nodo));

p=start;
p->next=NULL;
do{
sc=menu();
switch(sc){
case 'a': start=cons(start, p); break;
case 'd': start=delete(start, p); break;
case 's': stampa(start, p); break;
case 'l': start=leggi(start, p); break;
case 'w': scrivi(start, p); break;
case 'q': exit (0); }

}while(sc!='q');
}



void stampa(nodo *start, nodo *p){
while(start!=NULL)
{printf("%d--> ", start->num);
start=start->next;
}
printf("\n");
}


nodo *cons(nodo *start, nodo *p)
{ nodo *start2; int numero;
start2=(nodo *)malloc(sizeof(nodo));
printf("Inserisci numero: "); scanf("%d", &numero);
p=start2;
p->num=numero;
p->next=start ;
return (start2);
}


char menu()

{char sc; printf("A)dd, D)elete, S)tampa, L)oad, W)rite, Q)uit\n");
scanf("%c", &sc); return (sc); }

nodo *delete(nodo *start, nodo *p)
{int num_del; nodo *p2;
printf("Inserisci il numero che vuoi eliminare:");
scanf("%d", &num_del);
p2=start;
while(p2->next->num!=num_del)
{p2=p2->next;}
p2->next=p2->next->next;
return (start);
}
nodo *leggi(nodo *start, nodo *p)
{FILE *pf;
pf=fopen("numeri.txt", "r");
nodo *start3;
start3=(nodo *)malloc(sizeof(nodo));
p=start3;

if(pf)
{while(!feof(pf))
{fscanf(pf, "%d\t", &p->num); p=p->next;}
fclose(pf);
}else{printf("Errore nella lettura del file\n");}
p->next=start;
return(start3); }

void scrivi(nodo *start, nodo *p)
{FILE *pf;
pf=fopen("numeri.txt", "w");
if(pf)
{while(start!=NULL)
{fprintf(pf, "%d\t", start->num); start=start->next;}
fclose(pf);
}else{printf("Non è stato possibile scrivere il file\n");}
}

[Gimli[2BV!2B]]

In nodo *leggi(nodo *start, nodo *p) leggi tutto il file, ma allochi una sola struttura nodo.
Già il primo p=p->next ti porta un un punto qualsiasi della memoria (p->next non è inizializzato, dovrebbe puntare ad una nuova struttura allocata).

Anche nel delete vedo vari problemi:

salti il test sul primo elemento
non liberi la memoria (con free (http://www.manpagez.com/man/3/free/)) -> memory leak
pronto al botto se il numero non c'è!


Mi sfugge cosa vuoi fare con gli argomenti che passi alle funzioni, visto che spesso li sovrascrivi ed altre volte non li usi.

Per finire ti consiglio vivamente di scegliere uno stile di indentazione (http://en.wikipedia.org/wiki/Indent_style) e di mantenerlo per tutto il codice: quelle graffe buttate a caso sono fonte di errore e terribili da rintracciare nella lettura.

[vegetablu]

;35629234']In nodo *leggi(nodo *start, nodo *p) leggi tutto il file, ma allochi una sola struttura nodo.
Già il primo p=p->next ti porta un un punto qualsiasi della memoria (p->next non è inizializzato, dovrebbe puntare ad una nuova struttura allocata).

Anche nel delete vedo vari problemi:

salti il test sul primo elemento
non liberi la memoria (con free (http://www.manpagez.com/man/3/free/)) -> memory leak
pronto al botto se il numero non c'è!


Mi sfugge cosa vuoi fare con gli argomenti che passi alle funzioni, visto che spesso li sovrascrivi ed altre volte non li usi.

Per finire ti consiglio vivamente di scegliere uno stile di indentazione (http://en.wikipedia.org/wiki/Indent_style) e di mantenerlo per tutto il codice: quelle graffe buttate a caso sono fonte di errore e terribili da rintracciare nella lettura.

Ciao, perdonami ma è da poco che programmo con il C.
Adesso ti spiego meglio cosa devo fare. Si lo so che non ci sono controlli, ma momentaneamente non mi preoccupo, perchè il mio problema è altro e quindi quello è l'ultimo pensiero.

Ecco il codice più fluido, ma con sempre i problemi.
I problemi sono:
1) non so come si fa ad inserire un nome\stringa in un'allocazione di memoria;
2) non riesco a far leggere da file;
3) quando stampo, mi stampa sempre lo zero alla fine.
4) nella funzione delete mi elimina tutto tranne l'ultimo numero inserito.

Il testo di tutto l'esercizio vuole che io gestica un magazzino, la struttura deve contenere solo una stringa di char che indica il nome, e un int che indica la quantità dei pezzi. Ci devono essere le funzioni aggiungi pezzo, aggiorna le quantità del pezzo(preleva o aggiungi pezzo), cerca, elimina, stampa, rimuovi tutto, carica da file, salva su file. Dopo ogni operazione che faccio deve aggiornare i valori relativi al numero di tipi di ricambi e al numero complessivo di pezzi presenti.


Esempio:
A)ggiungi, C)erca, E)limina, R)imuovi tutto, P)releva, D)eposita, C)arica, S)crivi, E)sci.
p
Quale tipo di ricambio vuoi prelevare? Ruota
numero dei pezzi disponibili: 15
quanti pezzi vuoi prelevare? 3


#include <stdio.h>
#include <stdlib.h>
struct articolo{ char nome[20];
int q;
struct articolo *next;};
typedef struct articolo nodo;
char menu();
nodo *cons(nodo *start);
void stampa(nodo *start);
nodo *trova(nodo *start);
nodo *delete(nodo *start);
nodo *inserisci(nodo *start);

main(int argc, char **argv)
{char sc;

nodo *start;
start=(nodo *)malloc(sizeof(nodo));

/*
start->next=NULL;
*/

while(sc!='q')
{sc=menu();
switch(sc){
case 'a': start=cons(start); break;
case 'd': delete(start); break;
case 's': stampa(start); break;
case 't': trova(start); break;
case 'p': break;
case 'i': start=inserisci(start); break;
case 'l': break;
case 'w': break;
case 'q': exit (0); break;
}}
}



char menu()
{char sc;
printf("A)dd, D)elete, S)tampa, T)rova, P)relievo, I)nserisci, L)oad, W)rite, Q)uit.\n"); scanf("%c", &sc); return (sc);
}

nodo *cons(nodo *start)
{char *nom_prod; int quant; nodo *start2;
start2=(nodo *)malloc(sizeof(nodo));
start2->next=start;
/* printf("Inserisci Nome prodotto: ");
scanf("%s", nom_prod); */
printf("Inserisci la quantità: ");
scanf("%d", &quant);
start2->q=quant;

/* strcpy(start2->nome, nom_prod); */

return (start2);
}

void stampa(nodo *start)
{while(start!=NULL)
{/* printf("%s", start->nome); */
printf("%d ", start->q); start=start->next;}
printf("\n");
}

nodo *trova(nodo *start)
{int numero;
printf("Inserisci il numero che cerchi: ");
scanf("%d", &numero);
while(start->q!=numero)
{start=start->next;}
printf("Il numero da TE cercato è: %d\n", start->q);
}


nodo *delete(nodo *start)
{int num_del;
printf("Inserisci il numero che vuoi eliminare: ");
scanf("%d", &num_del);
while(start->next->q!=num_del){start=start->next;}
start->next=start->next->next;
printf("Il numero è stato correttamente eliminato\n");
}

nodo *inserisci(nodo *start)
{int pezzi_add;

printf("Quanti pezzi devo aggiungere? ");
scanf("%d", &pezzi_add);
start->q=start->q+pezzi_add;
return (start);
}

[vegetablu]

PS: Le parti inserite tra /* */ sono le parti che secondo il mio raggionamento sono esatte, ma purtroppo mi creano errori e non funzionano.

[darkito85]

Non la prendere a male ma mi sa che hai qualche problema con i puntatori, o con il C in generale. Ti consiglio vivamente di dare una ripassata al C e ai puntatori.
Al di la della indentazione il tuo codice ha errori un po ovunque, controlli non fatti, valori non ritornati, parametri di ingresso ed uscita passati "a casaccio".
L'unica funzione che non ha errori è la funzione di stampa.

[Gimli[2BV!2B]]

#include <stdio.h>
#include <stdlib.h>
#include <string.h> /*memset e funzioni stringhe*/

struct articolo{
char nome[20];
int q;
struct articolo *next;
};
typedef struct articolo nodo;

char menu();
nodo* cons(nodo *start);
void stampa(nodo *start);
nodo* trova(nodo *start);
nodo* delete(nodo *start);
nodo* inserisci(nodo *start);

main(int argc, char **argv)
{
char sc = 'z'; /*inizializza SEMPRE*/

nodo *start = (nodo *)malloc(sizeof(nodo));
memset((void *)start, 0x00, sizeof(nodo)); /*tutto il contenuto della struttura azzerato*/
/*Ah, a causa di questa allocazione iniziale avrai sempre un elemento*/
/*vuoto in coda alla lista; non credo sia ciò che desideri...*/

while( sc != 'q' )
{
sc = menu();
switch( sc )
{
case 'a':
start = cons(start);
break;
case 'd':
delete(start);
break;
case 's':
stampa(start);
break;
case 't':
trova(start);
break;
case 'p':

break;
case 'i':
start=inserisci(start);
break;
case 'l':

break;
case 'w':

break;
case 'q':
exit(0);
break;
}
}
}


char menu()
{
char sc;
printf("A)dd, D)elete, S)tampa, T)rova, P)relievo, I)nserisci, L)oad, W)rite, Q)uit.\n");
scanf("%c", &sc);
return sc;
}

nodo *cons(nodo *start)
{
nodo *nuovo = (nodo*)malloc(sizeof(nodo));
memset((void*)nuovo, 0x00, sizeof(nodo)); /*pulizie di primavera, come sopra*/
nuovo->next = start;
printf("Inserisci Nome prodotto: ");
scanf("%s", nuovo->nome); /*scanf di stringa: puoi usare direttamente la struttura*/
printf("Inserisci la quantità: ");
scanf("%d", &(nuovo->q)); /*idem per l'int, avendo l'accortezza di riferirsi all'elemento desiderato*/
return nuovo;
}

void stampa(nodo *start)
{
while(start!=NULL)
{
printf("%s: qty ", start->nome); /*questa immagino schiantasse a causa della mancata inizializzazione delle strutture (stringhe non terminate)*/
printf("%d\n", start->q);
start=start->next;
}
printf("\n");
}

nodo *trova(nodo *start)
{int numero;
printf("Inserisci il numero che cerchi: ");
scanf("%d", &numero);
while(start->q!=numero)
{start=start->next;}
printf("Il numero da TE cercato è: %d\n", start->q);
}


/*come ti ho scritto prima, questo delete non controlla il primo elemento*/
/*della lista, cioè l'ultimo inserito. Devi controllare start->q, non saltare*/
/*subito al next. Devi anche fare il delete del nodo.*/
nodo *delete(nodo *start)
{int num_del;
printf("Inserisci il numero che vuoi eliminare: ");
scanf("%d", &num_del);
while(start->next->q!=num_del){start=start->next;}
start->next=start->next->next;
printf("Il numero è stato correttamente eliminato\n");
}

nodo *inserisci(nodo *start)
{int pezzi_add;

printf("Quanti pezzi devo aggiungere? ");
scanf("%d", &pezzi_add);
start->q += pezzi_add;
return (start);
}
Tra commenti e correzioni dirette dovrei aver risposto a tutte le tue domande (più una porzione indentata a modo mio).
Ah, giusto, ho tralasciato il leggi da file: quello lo hai abbozzato, quando avrai ben capito come navigare nella lista e leggere i dati ti verrà molto più semplice: lascialo per ultimo, prima completa le funzioni interattive.
La scrittura su file dovrebbe essere ancora più semplice.

Trattandosi di un esercizio non posso andare oltre, devi capire ed applicare i suggerimenti, ma vedo che hai fatto varie prove, quindi confido che sarai in grado di procedere.
Visto che sei in Ubuntu ricordati che esistono anche le man per le funzioni C (http://packages.ubuntu.com/natty/manpages-dev), che son comode, solitamente ben scritte e, soprattutto, indicano comodamente quali header occorre includere per utilizzare tal funzione.

[vegetablu]

;35630385']#include <stdio.h>
#include <stdlib.h>
#include <string.h> /*memset e funzioni stringhe*/

struct articolo{
char nome[20];
int q;
struct articolo *next;
};
typedef struct articolo nodo;

char menu();
nodo* cons(nodo *start);
void stampa(nodo *start);
nodo* trova(nodo *start);
nodo* delete(nodo *start);
nodo* inserisci(nodo *start);

main(int argc, char **argv)
{
char sc = 'z'; /*inizializza SEMPRE*/

nodo *start = (nodo *)malloc(sizeof(nodo));
memset((void *)start, 0x00, sizeof(nodo)); /*tutto il contenuto della struttura azzerato*/
/*Ah, a causa di questa allocazione iniziale avrai sempre un elemento*/
/*vuoto in coda alla lista; non credo sia ciò che desideri...*/

while( sc != 'q' )
{
sc = menu();
switch( sc )
{
case 'a':
start = cons(start);
break;
case 'd':
delete(start);
break;
case 's':
stampa(start);
break;
case 't':
trova(start);
break;
case 'p':

break;
case 'i':
start=inserisci(start);
break;
case 'l':

break;
case 'w':

break;
case 'q':
exit(0);
break;
}
}
}


char menu()
{
char sc;
printf("A)dd, D)elete, S)tampa, T)rova, P)relievo, I)nserisci, L)oad, W)rite, Q)uit.\n");
scanf("%c", &sc);
return sc;
}

nodo *cons(nodo *start)
{
nodo *nuovo = (nodo*)malloc(sizeof(nodo));
memset((void*)nuovo, 0x00, sizeof(nodo)); /*pulizie di primavera, come sopra*/
nuovo->next = start;
printf("Inserisci Nome prodotto: ");
scanf("%s", nuovo->nome); /*scanf di stringa: puoi usare direttamente la struttura*/
printf("Inserisci la quantità: ");
scanf("%d", &(nuovo->q)); /*idem per l'int, avendo l'accortezza di riferirsi all'elemento desiderato*/
return nuovo;
}

void stampa(nodo *start)
{
while(start!=NULL)
{
printf("%s: qty ", start->nome); /*questa immagino schiantasse a causa della mancata inizializzazione delle strutture (stringhe non terminate)*/
printf("%d\n", start->q);
start=start->next;
}
printf("\n");
}

nodo *trova(nodo *start)
{int numero;
printf("Inserisci il numero che cerchi: ");
scanf("%d", &numero);
while(start->q!=numero)
{start=start->next;}
printf("Il numero da TE cercato è: %d\n", start->q);
}


/*come ti ho scritto prima, questo delete non controlla il primo elemento*/
/*della lista, cioè l'ultimo inserito. Devi controllare start->q, non saltare*/
/*subito al next. Devi anche fare il delete del nodo.*/
nodo *delete(nodo *start)
{int num_del;
printf("Inserisci il numero che vuoi eliminare: ");
scanf("%d", &num_del);
while(start->next->q!=num_del){start=start->next;}
start->next=start->next->next;
printf("Il numero è stato correttamente eliminato\n");
}

nodo *inserisci(nodo *start)
{int pezzi_add;

printf("Quanti pezzi devo aggiungere? ");
scanf("%d", &pezzi_add);
start->q += pezzi_add;
return (start);
}
Tra commenti e correzioni dirette dovrei aver risposto a tutte le tue domande (più una porzione indentata a modo mio).
Ah, giusto, ho tralasciato il leggi da file: quello lo hai abbozzato, quando avrai ben capito come navigare nella lista e leggere i dati ti verrà molto più semplice: lascialo per ultimo, prima completa le funzioni interattive.
La scrittura su file dovrebbe essere ancora più semplice.

Trattandosi di un esercizio non posso andare oltre, devi capire ed applicare i suggerimenti, ma vedo che hai fatto varie prove, quindi confido che sarai in grado di procedere.
Visto che sei in Ubuntu ricordati che esistono anche le man per le funzioni C (http://packages.ubuntu.com/natty/manpages-dev), che son comode, solitamente ben scritte e, soprattutto, indicano comodamente quali header occorre includere per utilizzare tal funzione.


Il problema è che tra 3 giorni ho un esame e devo almeno avere una copia esatta di questo programmma.


Ho riscritto tutto.
Potresti correggerlo?
E' pieno di errori e in questo momento, dato che sono sotto esami, ho la testa che non mi funziona più, non riesco a raggionare bene!
Aiutami!!!!!!!!!!!
Grazie!

Ecco il codice:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct articolo{ char nome[20];
int q;
struct articolo *next;};

typedef struct articolo nodo;
char menu();
nodo *cons(nodo *start);
void stampa(nodo *start);
nodo *trova(nodo *start);
nodo *delete(nodo *start);
nodo *inserisci_preleva(nodo *start);
nodo *prod_work(nodo *start);
void scrivi(nodo *start);
nodo *leggi(nodo *start);


main(int argc, char **argv)
{ char sc='\0';
char prod='\0';

nodo *start=NULL;

while(sc!='q')
{sc=menu();
switch(sc){
case 'a': start=cons(start); break;
case 'd': delete(start); break;
case 's': stampa(start); break;
case 't': trova(start); break;
case 'p': start=inserisci_preleva(start); break;
case 'l': start=leggi(start); break;
case 'w': scrivi(start); break;
case 'q': exit (0); break;
}
}
return 0;
}



char menu()
{char sc='\0';
printf("A)dd, D)elete, S)tampa, T)rova, P)releva o inserisci, L)oad, W)rite, Q)uit.\n"); scanf("%c", &sc);
return sc;
}

nodo *cons(nodo *start)
{char nom_prod[20];
int quant;
nodo *start2;

printf("Inserisci nome prodotto:\t");
scanf(" %s", nom_prod);

start2=(nodo *)malloc(sizeof(nodo));

if(start2!=NULL)
{ start2->next=start;
printf("Inserisci la quantità:\t");
scanf(" %d", &quant);

start2->q=quant;
strcpy(start2->nome, nom_prod);

return (start2);
}
return (start);
}

void stampa(nodo *start)
{while(start!=NULL)
{ printf("%s\t%d\n ", start->nome, start->q);
start=start->next;
}
printf("\n");
}

nodo *trova(nodo *start)
{char prod[20];
printf("Inserisci il nome dell'articolo che cerchi:\t");
scanf(" %s", prod);
if(start->nome!=NULL)
{while(start->nome!=prod)
{start=start->next;
}
return start;
}

printf("L'articolo da te cercato è: %s %d\n", start->nome, start->q);
return start;
}


nodo *prod_work(nodo *start)
{ char prod='\0';
printf("Inserisci il nome dell'articolo:");
scanf("%s", prod);
return prod;
}

nodo *delete(nodo *start)
{int num_del;
char prod='\0';

prod=prod_work(start);
while(start->next->nome!=prod)
{start=start->next;
}
start->next=start->next->next;
printf("Il numero è stato correttamente eliminato\n");
}

nodo *inserisci_preleva(nodo *start)
{int pezzi_add, pezzi_sub;
char sc='\0';
char prod='\0';

prod=prod_work(start);
while(start->nome!=prod)
{start=start->next;
}
printf("vuoi A)ggiungere o E)liminare pezzi? ");
scanf("%c", &sc);
switch(sc)
{case 'a': printf("QUanti pezzi vuoi aggiungere?");
scanf("%d", &pezzi_add); start->q=start->q+pezzi_add; break;

case 'e': if(start->q >0)
{printf("Quanti pezzi vuoi sottrarre?");
scanf("%d", &pezzi_sub); start->q=start->q-pezzi_sub;
}
else{printf("Non ci sono pezzi disponibili\n"); break;
}

return (start);
}

void scrivi(nodo *start)
{FILE *pf;
pf=fopen("numeri.txt", "w");
if(pf)
{while(start!=NULL)
{fprintf(pf, "%s\t %d\n", start->nome, start->q);
start=start->next;
}
fclose(pf);
}
else{printf("Non è stato possibile scrivere il file");
}
}

nodo *leggi (nodo *start)
{char nom_prod2[20];
int quant2;
nodo *tmp;

tmp=(nodo *)malloc(sizeof(nodo));

FILE *pf;
pf=fopen("numeri.txt", "r");
if(pf)
{ while(!feof(pf))
{fscanf(pf, "%s\t %d", nom_prod2, &quant2);
tmp->q=quant2;
strcpy(tmp->nome, nom_prod2);
tmp=tmp->next;
}
fclose(pf);
return tmp;

}
else{
printf("Errore lettura file\n");
}
return tmp;
}

[vegetablu]

Grazie alle vostre direttive sono riuscito a scrivere tutto il codice tranne due funzioni fondamentali:
1)la funzione cancella funziona con tutti trannne con il primo elemento della lista(infatti ho creato un nuovo nodo, ma non funziona lo stesso);
2)la funzione leggi.


Ecco il codice:


#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct articolo
{
char nome[20];
int q;
struct articolo *next;
};

typedef struct articolo nodo;


char menu();
nodo *cons(nodo *start);
void stampa(nodo *start);
void trova(nodo *start);
void deposita(nodo *start);
void prelieva(nodo *start);
nodo *cancella(nodo *start);
void scrivi(nodo *start);

int main(int argc, char **argv)
{
char sc = '\0';

nodo *start = NULL;

while(sc!='q')
{
sc=menu();
switch(sc)
{
case 'a': start=cons(start); break;
case 'd': cancella(start); break;
case 's': stampa(start); break;
case 't': trova(start); break;
case 'p': prelieva(start); break;
case 'i': deposita(start); break;
case 'l': break;
case 'w': scrivi(start); break;
}
}
return 0;
}



char menu()
{
char sc = '\0';
printf("A)dd, D)elete, S)tampa, T)rova, P)relievo, I)nserisci, L)oad, W)rite, Q)uit.\n");
scanf(" %c", &sc);
return sc;
}

nodo *cons(nodo *start)
{
char nom_prod[20];
int quant;
nodo *nuovo;

printf("Inserisci nome articolo:\t");
scanf(" %s", nom_prod);


nuovo=(nodo *)malloc(sizeof(nodo));
if(nuovo != NULL)
{
nuovo->next=start;

printf("Inserisci la quantità: ");
scanf(" %d", &quant);

strcpy(nuovo->nome,nom_prod);
nuovo->q=quant;
return nuovo;
}
return start;
}

void stampa(nodo *start)
{
while(start!=NULL)
{
printf("%s - %d\n", start->nome, start->q);
start=start->next;
}
printf("\n");
}


void trova(nodo *start)
{
char parola[20];
printf("Quale oggetto vuoi ricercare?\t");
scanf("%s", parola);

while( strcmp (parola, start->nome) !=0)
{
start=start->next;
}

printf("%s\t %d\n", start->nome, start->q); printf("\n");
}

void deposita(nodo *start)
{
char parola[20];
int pezzi;

printf("Quale oggetto vuoi ricercare?\t");
scanf("%s", parola);

while( strcmp (parola, start->nome) !=0)
{
start=start->next;
}
printf("Quanti pezzi devo aggiungere?\t");
scanf("%d", &pezzi);
start->q=start->q + pezzi;
printf("%s\t %d\n", start->nome, start->q); printf("\n");
}


void prelieva(nodo *start)
{
char parola[20];
int pezzi;

printf("Quale oggetto vuoi ricercare?\t");
scanf("%s", parola);

while( strcmp (parola, start->nome) !=0)
{
start=start->next;
}
printf("Quanti pezzi devo prelevare?\t");
scanf("%d", &pezzi);
if((start->q - pezzi) >= 0)
{
start->q=start->q - pezzi;
printf("%s\t %d\n", start->nome, start->q); printf("\n");
}else{
printf("Non puoi sottrarre %d pezzi, perchè in magazzino sono presenti solo %d pezzi\n", pezzi, start->q);
printf("\n");
}
}


nodo *cancella(nodo *start)
{
char parola[20]; nodo *nuovo2;
printf("Quale oggetto vuoi eliminare?\t");
scanf("%s", parola);

nuovo2=(nodo *)malloc(sizeof(nodo));
nuovo2->next=start;

while( strcmp (parola, nuovo2->next->nome) !=0)
{
nuovo2=nuovo2->next;
}
nuovo2->next=nuovo2->next->next;
printf("L'oggetto da te richiesto (%s) è stato correttamente ELIMINATO\n", parola);
printf("\n");

return start;
}


void scrivi(nodo *start)
{
FILE *pf;
pf=fopen("numeri.txt", "w");

if(pf)
{
while(start!=NULL)
{
fprintf(pf, "%s\t %d\n", start->nome, start->q);
start=start->next;
}
fclose(pf);
printf("Il file è stato scritto correttamente\n"); printf("\n");
}else
{
printf("Non è stato possibile scrivere il file\n");}
}

[darkito85]

Lo dico per te, secondo me devi studiarti meglio i puntatori, dal tuo codice vedo che hai le idee pochi chiare.

nodo *cancella(nodo *start)
{
char parola[20]; nodo *nuovo2,*tmp;
printf("Quale oggetto vuoi eliminare?\t");
scanf("%s", parola);
nuovo2=start;
if(!strcmp(nuovo2->nome,parola)) // se l'elemento si trova in prima posizione
{
start=start->next;
free(nuovo2);
printf("L'oggetto da te richiesto (%s) è stato correttamente ELIMINATO\n", parola);
printf("\n");
return start;
}
else
{
while (nuovo2->next!=NULL&&strcmp(nuovo2->next->nome,parola))
{
nuovo2=nuovo2->next;
}
if(nuovo2->next!=NULL) //elemento trovato!
{
tmp=nuovo2->next;
nuovo2->next=nuovo2->next->next;
free(tmp);
printf("L'oggetto da te richiesto (%s) è stato correttamente ELIMINATO\n", parola);
printf("\n");

return start;
}
else // elemento non trovato
{
printf("L'oggetto da te richiesto (%s) non è stato trovato \n", parola);
printf("\n");
return start;
}
}





Questa è la funzione delete per come dovrebbe essere scritta. Comunque ci sono diversi errori nel tuo sorgente. In pratica quasi sempre non consideri mai l'eventualità che la parola non venga trovata.
Ad esempio nella funzione trova dovresti aggiungere la riga:

void trova(nodo *start)
{
char parola[20];
printf("Quale oggetto vuoi ricercare?\t");
scanf("%s", parola);

while( strcmp (parola, start->nome) !=0)
{
start=start->next;
}
if(start!=NULL)
printf("%s\t %d\n", start->nome, start->q); printf("\n");
else
printf("Elemento non trovato");
}

[vegetablu]

Ok,
adesso spero di aver ben capito.
Mi manca solo la funzione LEGGI da file, che non capisco il perchè ma continua a non funzionare!

Potreste scrivermela???


Grazie, davvero non so come ringraziarvi!

[vegetablu]

Lo dico per te, secondo me devi studiarti meglio i puntatori, dal tuo codice vedo che hai le idee pochi chiare.

nodo *cancella(nodo *start)
{
char parola[20]; nodo *nuovo2,*tmp;
printf("Quale oggetto vuoi eliminare?\t");
scanf("%s", parola);
nuovo2=start;
if(!strcmp(nuovo2->nome,parola)) // se l'elemento si trova in prima posizione
{
start=start->next;
free(nuovo2);
printf("L'oggetto da te richiesto (%s) è stato correttamente ELIMINATO\n", parola);
printf("\n");
return start;
}
else
{
while (nuovo2->next!=NULL&&strcmp(nuovo2->next->nome,parola))
{
nuovo2=nuovo2->next;
}
if(nuovo2->next!=NULL) //elemento trovato!
{
tmp=nuovo2->next;
nuovo2->next=nuovo2->next->next;
free(tmp);
printf("L'oggetto da te richiesto (%s) è stato correttamente ELIMINATO\n", parola);
printf("\n");

return start;
}
else // elemento non trovato
{
printf("L'oggetto da te richiesto (%s) non è stato trovato \n", parola);
printf("\n");
return start;
}
}





Questa è la funzione delete per come dovrebbe essere scritta. Comunque ci sono diversi errori nel tuo sorgente. In pratica quasi sempre non consideri mai l'eventualità che la parola non venga trovata.
Ad esempio nella funzione trova dovresti aggiungere la riga:

void trova(nodo *start)
{
char parola[20];
printf("Quale oggetto vuoi ricercare?\t");
scanf("%s", parola);

while( strcmp (parola, start->nome) !=0)
{
start=start->next;
}
if(start!=NULL)
printf("%s\t %d\n", start->nome, start->q); printf("\n");
else
printf("Elemento non trovato");
}


Nella funzione cancella non mi elimina il primo elemento.
Nella funzione trova, se scrivo un elemento diverso va in errore.

L'ho appena provato incollando queste due tue funzioni.

[darkito85]

la funzione cancella devi chiamarla dal menù così:

start=cancella(start);

Per quanto riguarda la funzione trova il problema credo stia nella condizione del ciclo while. Prova ad usare questa.

void trova(nodo *start)
{
char parola[20];
printf("Quale oggetto vuoi ricercare?\t");
scanf("%s", parola);

while( start!=NULL&&strcmp (parola, start->nome) !=0)
{
start=start->next;
}
if(start!=NULL)
printf("%s\t %d\n", start->nome, start->q); printf("\n");
else
printf("Elemento non trovato");
}