Discussion :

[luffy.luck]

Je suis entrain d'essayer de creer une liste generique, mais j'ai quelques pb avec les templates.
Voila la classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#ifndef HEADER_LIST
#define HEADER_LIST
 
#include <iostream>
using namespace std;
// Classe liste
 
template <class T> class List {
 
    private:
        T m_val;
        List<T> *m_next;
 
    public:
        List() ;
        List(const List<T>&) ;
        ~List();
        void addTail(T);
}...

Le source qui va avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#include "list.h"
 
//Methods canonic Copelian Form
 
template <class T>
List<T>::List(){
    m_next = NULL;
}
 
 
template <class T>
List<T>::List(const List &l){
    if (l.m_next == NULL) m_next = NULL;
    else{
        while (l.m_next != NULL){
            addTail(l.m_val);
        }
    }
}
 
 
template <class T>
List<T>::~List(){
    if (m_next != NULL) delete m_next;
}
 
 
template <class T>
void
List<T>::addTail(T element){
    List<T> *newElem = new List;
    newElem->m_next;
    newElem->m_val = element;
 
    m_next = newElem;
}

Le main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
#include "list.h"
 
int main(){
    List<int> my_list;
 
    my_list.addTail(2);
    //my_list.addTail(1);
 
    return 0;
}

et a la compilation :
main.cpp.text+0x195): undefined reference to `List<int>::List()'
main.cpp.text+0x1a8): undefined reference to `List<int>::addTail(int)'
main.cpp.text+0x1b8): undefined reference to `List<int>::~List()'
main.cpp.text+0x1ce): undefined reference to `List<int>::~List()'

c'est la premiere fois que j'utilise les templates alors... J'aurais besoin d'aide
Merci d'avance

[JolyLoic]

http://cpp.developpez.com/faq/cpp/?p...VERS_templates

[luffy.luck]

Ben j'ai deja lu les FAQ, mais se que je voudrais savoir c'est se qui va pas dans mon programme...

J'arrive pas a trouver l'erreur...

[luffy.luck]

En fait merci, j'ai pigé, je pensais avoir un probleme au niveau du code et pas de la compilation... .
Ducoup c'est bon tout fonctionne.
Merci encore.

[koala01]

Salut, et bienvenue sur le forum.

Ceci dit, et d'un point de vue purement sémantique...

La liste est normalement le conteneur qui va fournir les différentes possibilités de... gestion du contenu.

C'est à dire que la liste va permettre d'ajouter, d'insérer, de retirer ou de rechercher des éléments.

Or, dans le code que tu présente, ce n'est pas ce que va faire ta classe template List: elle représente... le contenu (l'élément de la liste, en quelque sorte )

D'un point de vue purement sémantique, il serait donc utile / intéressant d'utiliser des termes qui ne mentiront pas à l'utilisateur.

Il faudrait donc plutot envisager quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* les éléments de la liste */
template <class T>
class ElementList
{ 
    private:
        T m_val;
        ElementList<T> *m_next;
 
    public:
        ElementList() ;
        ElementList(const List<T>&) ;
        ~ElementList();
        /* une version constante et une autre non constante, pour le cas où */
        ElementList& next();
        const ElementList& next() const;
 
};
/* la liste en elle même */
template <class T>
class List
{
    typedef ElementList<T>* ptrElem; /* par facilité */
    private:
        ptrElem m_first; // le premier élément de la liste
        ptrElem m_last; // le dernier élément de la liste 
        size_t m_size; // il est toujours sympa de pouvoir avoir le nombre 
                       // d'elements
 
    public:
        List() ;
        List(const List<T>&) ;
        ~List();
        void addTail(T);
        void addHead(T);
        void insertAfter(T);
        size_t size() const;
}

[HanLee]

Bof, question de définition.

Une liste est souvent définie par induction structurelle. A partir des règles suivantes :
- l'ensemble vide {} est une liste d'entiers
- si n est un entier et L est une liste, alors le couple (n, L) est une liste d'entiers.
Et on définit l'ensemble des listes d'entiers comme le plus petit ensemble clos par l'application de ces règles.

Là, tu vois bien que c'est une liste.
1, 2, 3, 4 <=> (1, (2, (3, (4, {}))))

Une liste est donc une valeur au même titre qu'un entier, et on applique des fonctions et traitements sur cette liste.

Et tu te rends compte que la liste définie par luffy.luck correspond bien à la définition (et même plus... tu peux avoir des listes infinies, en faisant des cycles).

Par contre, le problème en C++ c'est que faire une classe comme ça a une sémantique d'entité, et qu'il faut gérer la mémoire.

Ca explique tout le design des classes de la STL comme std::list, std::set, std::map.

Remarque, si on fait tout avec des boost::shared_ptr, en programmant sans effets de bord (naturellement par récursion), ça optimise l'espace mémoire parce que tout est partagé, et l'ensemble des listes manipulées peut s'entrelacer jusqu'à faire un graphe.