Newsgroup: it.comp.lang.c
Titolo: Liste dinamiche, che cos'ha questo programma?

Ciao a tutti, vi sottopongo il seguente programma, miè stato assegnato come 
esercizio sulle liste dinamiche; in pratica chiede all'utente una serie di 
interi da memorizzare in una lista dinamica; successivamente chiede un 
valore soglia e dopodichè stampa tutti gli interi della lista dinamica 
maggiori di quel valore soglia...vi posto il codice del programma che ho 
scritto; a volte va a volte non va, non capisco dov'è l'errore. Grazie 1000 
a tutti.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
        typedef struct el {
    int n;
    struct el* prox;
     } tipolista;
        tipolista* lista;
 int soglia;
 int var_appoggio;
 tipolista* cursore;
clrscr();
 lista=NULL;
 cursore=NULL;
 var_appoggio=0;
 lista=malloc(sizeof(tipolista));
 cursore=lista;
 printf("Inserisci dei numeri interi");
do
{
 scanf("%d",&(cursore->n));
 var_appoggio=cursore->n;
 cursore=cursore->prox;
}  while (var_appoggio!=0);
 cursore->prox=NULL;
 printf("Inserisci un valore intero(soglia)");
scanf("%d",&soglia);
 cursore=lista;
 while(cursore!=NULL)
 {
 if((cursore->n) > soglia)
  {
  printf("%d",cursore->n);
  }
 cursore=cursore->prox;
 }
} 

 Ora cursore punta alla successiva struttura ma dove l'hai allocata?
Ok, quindi la funzione malloc andrebbe messa dentro al ciclo in modo che ad 
ogni intero venga allocata una struttura giusto? ma quindi il puntatore 
lista non sarebbe più la testa della lista e io mi perdo l'inizio della 
lista dinamica...potresti essere più chiaro per favore?
Ti ringrazio per il tempo che mi hai dedicato.

 lista dinamica...potresti essere più chiaro per favore?
E' corretto quello che dici riguardo il posizionare malloc() all'interno 
del ciclo.
Il problema però che ti poni è errato.
Cioè tu all'inizio possiedi una variabile 'lista' che è un puntatore a 
tipolista, e lo inizializzi con una malloc().
A questo punto dovresti sfruttare la variabile cursore per identificare 
sempre l'ultimo elemento della tua lista, che creerai dinamicamente in 
quel loop:
cursore = lista = malloc(...);   // Creo il primo elemento
cursore->prox = cursore->n = 0;  // Inizializzo a zero
do
{
   scanf("%d", var_appoggio);
   cursore->n = var_appoggio;
   /* Se non ho inserito 0 allora sicuramente dovrò inserire qualcosa
      al prossimo giro di loop, quindi creo un nuovo elemento
      e ci punto con la variabile cursore
   */
   if (var_appoggio)
   {
     cursore->prox = malloc(sizeof(tipolista));
     cursore = cursore->prox;
   };
} while (var_appoggio);
P.S.: Il codice non l'ho testato, ma il concetto è questo.
E comunque mancherebbero i controlli per il risultato delle varie 
malloc(), perchè il s.o. potrebbe anche non volerti allocare quello che 
chiedi e tu, ignaro di tutto, continueresti a presumere che tutto sia OK.
-- 
Quando noi ignoranti eravamo di più, tutto era più bello (A. Celentano).
  ___   _   ___ _  _______   _______ ___
|   \ /_\ | _ \ |/ / _ ) \ / /_   _| __|
| |) / _ \|   / ' <| _ \\ V /  | | | _|
|___/_/ \_\_|_\_|\_\___/ |_|   |_| |___|

 chiedi e tu, ignaro di tutto, continueresti a presumere che tutto sia OK.
Perfetto, ho capito quello che volevo capire :-) grazie 1000 

Comunque dovresti anche provvedere a deallocare l'intera lista, che non 
si riduce semplicemente a deallocare il primo elemento :)
Ho buttato giů questo:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct el
{
     int n;
     struct el* next;
     struct el* prev;
} tipolista;
int main(int argc, char *argv[])
{
   tipolista *primo, *ultimo, *p=0;
   int var_appoggio;
   // Creo il primo elemento, che non punta a nulla
   primo = ultimo = malloc(sizeof(tipolista));
   primo->next = primo->prev = 0;
   primo->n = 0;
   printf("Inserisci dei numeri interi:\n");
   do
   {
       scanf("%d", &var_appoggio);
       ultimo->n = var_appoggio;
       if (var_appoggio)
       {
           /* Creo un nuovo elemento, lo azzero,
              e lo rendo raggiungibile dalla lista */
           p = malloc(sizeof(tipolista));
           p->next = 0;
           p->n = 0;
           p->prev = ultimo;
           ultimo->next = p;
           // Ora la variabile 'ultimo' punta al nuovo elemento
           ultimo = p;
           p = 0;
       };
   } while (var_appoggio);
   /*
      Qui ci va tutto il codice per scegliere un numero
      e stampare solo quegli elementi della lista che siano
      maggiori del numero dato in input
      ...
   */
   // E qui elimino la lista
   do
   {
       p = ultimo;
       ultimo = ultimo->prev;
       free(p);
   } while (ultimo);
   return 0;
}
-- 
Quando noi ignoranti eravamo di piů, tutto era piů bello (A. Celentano).
