C ++简单链表尝试：不太了解发生了什么

Question

I tried to strictly implement in c++ what I'm studying in algorithmic at the moment, recursive functions with simple linked lists. Here is what I've come by :

#include <iostream>
using namespace std;

class Liste {
    private :
        int val;
        Liste *suivante;
    public :
        Liste(int val = 0, Liste *suivante = NULL) {
            this->val = val;
            this->suivante = suivante;
        }
        void afficherElement() const {
            cout << "Adresse : " << this << endl;
            cout << "Valeur : " << val << endl;
            cout << "Adresse suivante : " << suivante << endl;
            cout << endl;
        }
        int tete() const {
            return val;
        }
        Liste reste() const {
            return *suivante;
        }
        bool estVide() const {
            return (suivante == NULL);
        }
        Liste prefixer(int val) {
            Liste *nouvelle = new Liste(val, this);
            return *nouvelle;
        }
        Liste suffixer(int val) {
            suivante = new Liste(val);
            afficherElement(); // test (last element won't be displayed)
            return *suivante;
        }
};

int main() {
    Liste uneListe(3); // 1st element
    uneListe.suffixer(5).suffixer(8).suffixer(10); // adding 3 more

    cout << "-----------\n\n";

    uneListe.afficherElement(); // displaying 1st element : ok
    uneListe.reste().afficherElement(); // displaying 2nd element : pointer is NULL !!???
    // uneListe.reste().reste().afficherElement(); --> segmentation fault, predictably enough

    return 0;
}

As you can guess, it doesn't work. When I add elements, calling the display method within the add method, elements seem to be well formed although the pointer value and the next element's adress differ (I don't get why). But, after adding process is done, I try to display the list again, 1st element is well linked with 2nd, but then there is a NULL pointer value. Wonder why ?? I've seen a code with two classes ( Node and Lis t), that works fine, but I'd like to know what is wrong with mine. Is it that I'm creating new objects of a class within this same class ?

Thanks,

Answer 1

Class Liste contains a value and a reference, which is not what a list is: a singly linked list is a pointer to an element containing a value and a pointer to the next node.

You might use a value+pointer element as a list object, ignoring the val member. This would require different coding for some methods, eg, for tete() and reste().

But, since using

typedef Liste * real_list_type;

is what you have in mind (? - see below), let's look at the methods.

bool estVide() const { return (suivante == NULL); }

This is in contradiction to the real_list_type being a mere List *; if you compare this to method reste(), it actually tests whether the tail is empty, not the list itself! (It would be in sync with using a value+pointer object as the list object.)

Liste suffixer(int val) { suivante = new Liste(val); ... }

This is bad: it replaces suivante with a new object, no matter what's stored in there (a memory leak). You'll have to do

Liste suffixer(int val) {
  if( suivante == NULL ){
     suivante = new Liste(val);
  } else {
     suivante->suffixer( val );
  }
  return *this;
}

LATER

I think that would be the best way to keep it as close to the abstract concept as possible. Note that there is no "isEmpty" - this is done by a test whether the List * variable representing the list equals NULL, but you can't have a method for that.

template<typename T>
class List {
public:
  List( T v, List* t = nullptr ) : value(v), next(t){}
  ~List(){ delete next; }
  List* prepend( T v ){
    return new List( v, this );
  }
  List* append( T v ){
    if( next == nullptr ){
      next = new List( v );
    } else {
      next->append( v );
    }      
    return this;
  }
  T head(){ return value; }
  List* tail(){ return next; }
  void dump(){
    List* curr = this;
    std::string del = "";
    while( curr != nullptr ){
      std::cout << del << curr->value;
      del = ", ";
      curr = curr->next;
    }
   std::cout << std::endl;
  }

private:
  T value;
  List* next;
};

int main(){
  typedef List<int> * intList;
  intList list = new List<int>( 1 );
  list->append( 2 )->append( 3 );
  list->dump();
}

Answer 2

for right this problem you most change this line
Liste suffixer(int val)
to
Liste* suffixer(int val)

and then change this line
return *suivante;
to
return suivante;
and in main use this line
uneListe.suffixer(5)->suffixer(8)->suffixer(10);
instead of
uneListe.suffixer(5).suffixer(8).suffixer(10);

Answer 3

Your class methods Liste::prefixer(int val) and Liste suffixer(int val) will return a copy of the object created, they should return a pointer to the object (or a reference).

eg

Liste *Liste::suffixer(int val){
    if(suivante == nullptr)
        suivante = new Liste(val);
    else
        throw std::runtime_error("Generic error message");

    return suivante;
}

or

Liste &Liste::suffixer(int val){

    ... previous inner method ...

    return *suivante;
}

Answer 4

Here is the "fixed" version of my first attempt :

#include <iostream>
using namespace std;

class Liste {
private :
    int val;
    bool vide;
    Liste *suivante;
public :
    Liste(int val = 0, bool vide = true, Liste *suivante = NULL) {
        this->val = val;
        this->vide = vide;
        this->suivante = suivante;
    }
    void afficherElement() const {
        cout << "Adresse : " << this << endl;
        cout << "Valeur : " << val << endl;
        cout << "Vide : " << vide << endl;
        cout << "Adresse suivante : " << suivante << endl;
        cout << endl;
    }
    int head() const {
        return val;
    }
    Liste *reste() const {
        return suivante;
    }
    bool estVide() const {
        return vide;
    }
    Liste *prefixer(int val) {
        Liste *nouvelle = new Liste(val, this);
        return nouvelle;
    }
    Liste *suffixer(int val) {
        if(suivante == NULL) {
            suivante = new Liste(val);
            vide = false;
        }
        return suivante;
    }
};

void afficherListe(Liste *uneListe) {
    (*uneListe).afficherElement();
    if(!(*uneListe).estVide()) {
        afficherListe((*uneListe).reste());
    }
}

int main() {
    Liste *test = new Liste(3);
    (*test).suffixer(5);
    afficherListe(test);
    return 0;
}

As expected it's awfully unpractical. Laune's solution looks good... However, the whole thing is bizarre, I suppose I'd be better off sticking with the regular List/Nodes way. Definitely gonna talk about that with my teacher.