Newsgroup: it.comp.lang.c++
Titolo: Sto facendo un corso. Aiuto per puntatori e lista dinamica.

Ciao a tutti. Sto facendo un corso di c++ ma non riesco a capire le liste
linkate.
Ho capito che NEW mi crea uno spazio di memoria di un certo tipo, e mi
restituisce il puntatore a quell'ind. mentre DELETE libera questo spazio.
Il problema č: in una STRUCT (lista linkata)con: un valore e un puntatore
alla STRUCT stessa, se creo un nuovo tipo stuct come inserisco il puntatore
alla cella successiva?
E come si fa a cancellare l'indirizzo corrente e a recuperare i gli
indirizzi che contengono i valori vecchi?
In pratica: io sono arrivato a fare questo programma, ma non mi funziona.
Per favore mi dite dove sbaglio?
#include <iostream.h>
main(){
 struct linkl {                 //Creo una struct che contiene
  int val;                         //un valore
  linkl *next;};               //e un puntatore alla cella successiva:
 linkl lista ;                     //lista.
 linkl *lista_ptr;             //Creo un puntatore di tipo struct linkl
 lista.val=1;                  //Assegno il primo valore alla struct
 lista_ptr=new linkl;     //Creo un nuovo spazio di memoria di tipo linkl
 lista.next=lista_ptr;      //Assegno il nuovo spazio di memoria a
lista.next.
 lista.next->val=lista.val;//Posiziono il valore in val caricato prima nel
nuovo spazio a cui punta next.
 lista_ptr=new linkl;      //Ricreo un altro spazio
 lista.next=lista_ptr;     //Assegno il nuovo spazio a lista.next
 lista.val=2;                 //Un altro valore a val
 lista.next->val=lista.val;//e lo sposto nel nuovo spazio a cui punta next
cout<<lista.val<<endl; // Quindi dovrei avere 2 locazioni dove c'e un
oggetto 1 e un oggetto 2.
 lista_ptr=new linkl;    //Ripieto per un altra nuova struct
 lista.next=lista_ptr;    //nuovo in puntatore
 lista.val=3;                //altro valore
 lista.next->val=lista.val; //sposto in nuovo ind. cui punta next
cout<<lista.val<<endl;
 delete lista_ptr;             //libero la memoria (struct linkl) occupata
dall'ultimo new
 cout<<lista.val<<endl;  //e a questo punto perchč il puntatore non ha piu
il pen'ultimo indirizzo dove lista.val=2?
 lista.next=lista_ptr;
 lista.val=lista.next->val; //recupero il pen'ultimo valore di val
cout<<lista.val<<endl;   //ma mi stampa un valore a caso.
}
Scusate il casino. Grazie a chi mi risponde.

 Per favore mi dite dove sbaglio?
Non ho capito bene il codice che hai postato, comunque credo che tu faccia
un errore concettuale: si deve partire da un elemento allocato
dinamicamente, che va fatto puntare da un puntatore che non devi modificare
(serve per poter visitare la lista, in seguito); poi, quando allochi nuovi
elementi, fai puntare next a 0, e fai puntare il nuovo dal next del
precedente elemento allocato (che nell'iterazione precedente avevi fatto
puntare a 0). Prova a dare un'occhiata al seguente codice, che puoi
compilare:
#include <iostream>
using namespace std;
struct linkl {
    int val;
    linkl *next;
};
linkl * add(int val) {
    // aggiungo un elemento e gli assegno il valore passato
    linkl *nuovo=new linkl;
    nuovo->val=val;
    nuovo->next=0;
    return nuovo;
}
void free(linkl *curr) {
    // libero la memoria allocata per la lista
    while (curr) {
        linkl *tmp=curr;
        curr=curr->next;
        delete tmp;
    }
}
int main(){
    linkl *start=0, *curr=0;
    for (int i=0; i<10; i++) {
        if (!start) {
            file://lista vuota
            start=add(i);
            curr=start;
        }
        else {
            curr->next=add(i);
            curr=curr->next;
        }
    }
    curr=start;
    while (curr) {
        cout << curr->val << endl;
        curr=curr->next;
    }
    free(start);
    system("pause");
    return 0;
}

Grazie, ho capito dove sbagliavo.
Mi mancava il puntatore al primo elemento:
     start=add(i);
     curr=start;
Non posizionavo il puntatore corrente all'elemento successivo, sia in
inserimento che in lettura:
        else {
            curr->next=add(i);
            curr=curr->next;
        }
Quindi anche delete lo usavo in modo sbagliato.
Ciao. Thomas.