Newsgroup: it.comp.lang.c
Titolo: Stampa non corretta di una lista

Salve a tutti, 
ho implementato una lista monodirezionale di interi con i puntatori in
C, però in fase di stampa il primo elemento non viene considerato.
Potreste dare un'occhiata al codice ?
#include <stdio.h> 
#include <stdlib.h> 
#include <conio.h> 
// Definizioni di tipo 
struct cella {int valore; struct cella *successivo;}; 
typedef struct cella *pos, *lista; 
typedef int boolean; 
// Prototipi degli operatori 
void Crealista(lista *); 
boolean Listavuota(lista); 
int Leggilista(pos, lista); 
boolean Finelista(pos ,lista); 
pos Succlista(pos, lista); 
pos Predlista(pos, lista); 
void Inslista(pos, int, lista *); 
void Scrivilista(pos, int, lista *); 
void Canclista(pos, lista *); 
pos Primolista(lista); 
void main() 
{ 
lista L; 
pos p; 
int i, val; 
clrscr(); 
Crealista(&L); 
p=Primolista(L); 
printf("** LISTA MONODIREZIONALE DI INTERI IMPLEMENTATA CON PUNTATORI
**\n\n");
for(i=0;i<10;i++) 
{ 
printf("Inserire il %d^ elemento: ", i+1); 
scanf("%d", &val); 
Inslista(p, val, &L); 
p=Succlista(p, L); 
} 
printf("\nGli elementi della lsta sono i seguenti: "); 
for(p=Primolista(L); (!Finelista(p, L)); p=Succlista(p, L)) printf("%d
", Leggilista(p, L));
printf("\n\nGrazie per aver utilizzato il programma.\n"); 
} 
// Realizzazione degli operatori 
void Crealista(lista *L) 
{ 
*L=NULL; 
} 
boolean Listavuota(lista L) 
{ 
return((L==NULL) ? 1 : 0); 
} 
int Leggilista(pos p, lista L) 
{ 
if (!Listavuota(L) && !Finelista(p, L)) return((p==NULL) ? L->valore :
(p->successivo)->valore);
else 
{ 
printf("Lista vuota, impossibile leggere il valore.\n"); 
return -1; 
} 
} 
boolean Finelista(pos p, lista L) 
{ 
return((p==NULL) ? (L==NULL) : ((p->successivo)==NULL)); 
} 
pos Succlista(pos p, lista L) 
{ 
if (!Finelista(p, L)) 
{ 
return((p==NULL) ? L : (p->successivo)); 
} 
else 
{ 
printf("Lista terminata: impossibile calcolare l'elemento
successivo.\n");
return NULL; 
} 
} 
pos Predlista(pos p, lista L) 
{ 
pos q; 
if (p!=NULL) 
{ 
if (p==L) return NULL; 
} 
else 
{ 
q=L; 
while (q->successivo!=p) q=q->successivo; 
return q; 
} 
} 
void Inslista(pos p, int a, lista *L) 
{ 
pos temp; 
if (p==NULL) 
{ 
temp=*L; 
(*L)=malloc(sizeof(lista)); 
(*L)->successivo=temp; 
(*L)->valore=a; 
} 
else 
{ 
temp=p->successivo; 
(p)->successivo=malloc(sizeof(pos)); 
p->successivo->successivo=temp; 
p->successivo->valore=a; 
} 
free(temp); 
} 
void Scrivilista(pos p, int a, lista *L) 
{ 
if (!Finelista(p, *L)) 
{ 
if (p==NULL) (*L)->valore=a; 
else p->successivo->valore=a; 
} 
else printf("Lista terminata: impossibile aggiungere l'elemento.\n"); 
} 
void Canclista(pos p, lista *L) 
{ 
if (!Finelista(p, *L)) 
if (p==NULL) (*L)=(*L)->successivo; 
else p->successivo=(p->successivo)->successivo; 
} 
pos Primolista(lista L) 
{ 
return L; 
} 
Grazie a quanti risponderanno !

 (p->successivo)->valore);
   ^^^^^^^^^^^^^^^^^^^
Potresti correggere mettendo semplicemente p->valore, ma in tal caso, per
come hai fatto il ciclo di lettura nel main, non leggeresti l'ultimo
elemento della lista.
Mi pare che comunque tu abbia scritto un codice un pò criptico, forse
faresti meglio a ripulirlo un pochino.
Ciao,
Cecco

 Potreste dare un'occhiata al codice ?
Se te ne scrivo una versione migliore ti va bene uguale? Non sono un
grandissimo fenomeno in C, ma (ammetto l'ignoranza) sono riuscito a capire
solo in parte il tuo codice (è un po' incasinato, x i miei gusti ^^;;;)...
/*
 * Implementazione di una lista monodirezionale
 */
#include <stdio.h>
#include <stdlib.h>
/* Definisco la struttura della mia lista */
struct lista {
                            int val;
                            struct lista *next;
                    };
/* Prototipi di funzione */
struct lista *insert (struct lista *l, int n);
struct lista *delete (struct lista *l, int n);
void visualizza (struct lista *l);
int main() {
                        struct lista *p;
                        int elem;
                        p=NULL;
                        /* l'implementazione di un eventuale menu
                         * te la evito per far prima */
                        printf("Inserisci elemento: ");
                        scanf("%d", &elem)
                        p=insert(p, elem);
                        printf("Inserisci elemento da cancellare: ");
                        scanf("%d", &elem);
                        p=delete(p, elem);
                        visualizza(p);
                 }
struct lista *insert(struct lista *l, int n)
        {
                    if (l==NULL)
                            {
                                        l=(struct lista
*)malloc(sizeof(lista));
                                        /* Io ho esplicitato il cast, ma non
so quanto
                                         * quanto sia corretto farlo */
                                        l->val=n;
                                        l->next=NULL;
                                        return l;
                    else
                            {
                                        l->next=insert(l->next, n); /*
chiamata ricorsiva */
                                        return l;
                            }
        }
struct lista *delete (struct lista *l, int n)
        {
                    struct lista *tmp; /* dichiaro una lista di appoggio */
                     if (l==NULL) /* Caso di lista vuota */
                                return NULL;
                     else if (l->val==n) /* Caso in cui trovi l'elemento da
eliminare */
                            {
                                        tmp=l->next;
                                        free(l);
                                        return (tmp);
                              }
                      else
                              {
                                        l->next=delete(l->next, n);
                                        return l;
                               }
        }
void visualizza (struct lista *l)
        {
                    if (l != NULL)
                            {
                                    printf("%d ", l->val);
                                    visualizza(l->next);
                            }
        }
Poi da qui ci fai tutte le altre funzioni riguardanti le liste (es.
inserimento in testa, lista ordinata, cancellazione dell'ultimo elemento
della lista and so on).
Spero di non aver scritto cretinate... =/
Ciao
Marco

...

Grazie mille Cecco,
per aver risposto ! Sei davvero molto gentile.
Cosa intendi per codice criptico ? Mi sapresti dare qualche dritta per
ripulirlo un pò ? Te ne sarei grato ! Ci sono altri errori nel codice,
a tuo avviso ?
Grazie anticipatamente ! :)