Discussion :

[Gébix]

Bonjour,

J'ai un problème que je ne comprends pas. J'ai créé une classe héritant de QList :

Code :

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

1
2
3
4
5
6
7
8
template<class T>
class A: public QList<<T> > {
...
 
int f() {
    return size();
}
}

et j'obtiens l'erreur suivante :

there are no arguments to ‘size’ that depend on a template parameter, so a declaration of ‘size’ must be available

Quelqu'un pourrait-il m'aider ? Est-ce que j'ai zappé quelque chose d'important dans la déclaration de ma classe ?

[Gymble]

Quand tu hérites d'une base template tu dois préfixer les appels des fonctions de la base par son type.

Code :

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

1
2
3
int f() {
    return QList<T>::size();
}

Soit dis en passant j'aurais plutôt tendance a faire

Code :

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

1
2
3
4
5
6
template<class T>
class A: public QList<T> 
{
public:
    using QList<T>::size;
}

Ceci bien sur dans la mesure ou tu n'a pas besoin de changer le comportement de la fonction size de la classe de base.
Attention également, dans le cas de la STL et potentiellement de ton QList, le destructeur n'est pas virtuel.

[Trademark]

Généralement c'est une très mauvaise idée d'hériter d'un container. Il faut que tu envisages la composition ! Notamment parce que aucunes méthodes n'est virtuelles.

Sujet déjà abordé ici : http://www.developpez.net/forums/d25...eriter-vector/

et la : http://www.developpez.net/forums/d77...r-classes-stl/

[gbdivers]

Et la FAQ : Pourquoi et quand faut-il créer un destructeur virtuel ?
Et je vais insister plus que les 2 autres intervenants : tu dois pas faire ça

[Gébix]

Bon ben je vais révisé ma copie

Merci pour vos réponses !

[Gébix]

@Gymble : les <> sont un oubli de ma part, j'aurais dû les effacer.

Sinon, je vais passer par la composition même si cette solution ne m'enchante pas trop puisque cela demande d'écrire du code supplémentaire.

[koala01]

Salut,

@Gymble : les <> sont un oubli de ma part, j'aurais dû les effacer.

Sinon, je vais passer par la composition même si cette solution ne m'enchante pas trop puisque cela demande d'écrire du code supplémentaire.

Heuu... sincèrement... :

1. Le code supplémentaire à écrire tient en trois ou quatre fonctions et éventuellement deux typedef
2. Le code supplémentaire à écrire tient, en gros, à simplement appeler les fonctions de QList

ce sera sans doute du genre de :

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
 
template <typename T>
class A
{
        typedef QList<T> list;
    public:
        typedef typename list::iterator iterator;
        typedef typename list::const_iterator const_iterator;
        A & operator << (T const & toadd)
       {
           list_<< toadd;
           return *this;
       }
       iterator begin() {return list_.begin();}
       iterator end() {return list_.end();}
       const_iterator begin() const {return list_.begin();}
       const_iterator end() const  {return list_.end();}
       bool isEmpty() const{retun list_.isEmpty();}
       size_t size() const{return list_.size();}
       T & operator [](size_t index){return list_[index];}
       T const & operator [](size_t index) const {return list_[index];}
    private:
        list_ list_;
};

(ca m'a pris royalement deux minutes trente à écrire ce code "from scratch" ... meme si j'écris peut etre très vite )

Ce n'est peut etre pas vraiment gai, mais bon, ce n'est pas la mort non plus

Sans oublier que tu peux parfaitement envisager l'héritage privé et les directives using

Mais bon, deux questions demeurent sans réponse :

Etant donné que A est une classe template, tu dis, d'office, adieux à la virtualité (template et virtualité, dans le cas présent, ne font pas bon ménage)...

Que Prévois tu donc de faire avec cette classe A qui aurait pu justifier que tu hérite de QList et que tu n'aurais pas pu faire avec ... QList

N'aurais tu pas pu te contenter de créer des fonctions libres qui auraient eu un comportement identique

Finalement, avec des fonctions libres template, tu aurais sans dout très bien pu arriver au même résultat :

Code :

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

1
2
3
4
5
6
 
template <typename T>
void foo( QList<T> const & laliste /* , autres paramètres éventuels*/ )
{
    /* utilisation de laliste */
}

Et cela ne t'aurait meme pas empêché de surcharger la fonction pour une QList contenant des objets d'un type particulier

Code :

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

1
2
3
4
void foo(QList<MonTypeParticulier /* * */ > laliste /* ,autres paramètres éventuels*/ )
{
    /* utilisation de laliste, adapté spécifiquement à  MonTypeParticulier  (*)*/
}

[gbdivers]

D'un autre côté, l'erreur de Gébix est compréhensible : on lui dit qu'il ne faut pas hériter de QList, mais si on regarde la doc de QList, on voit que plusieurs conteneurs de Qt dérivent de QList

On l'a déjà dit, mais c'est bien de la rappeler : Qt n'est pas un exemple à suivre en terme de qualité du code C++

[koala01]

D'un autre côté, l'erreur de Gébix est compréhensible : on lui dit qu'il ne faut pas hériter de QList, mais si on regarde la doc de QList, on voit que plusieurs conteneurs de Qt dérivent de QList

On l'a déjà dit, mais c'est bien de la rappeler : Qt n'est pas un exemple à suivre en terme de qualité du code C++

En outre, je viens de "percuter" sur le fait que l'héritage d'une classe template avec une classe template ne pose pas les mêmes problèmes que l'héritage d'une classe non template avec une classe template

[Gébix]

@koala01 : faut que je reréfléchisse à comment je recoder mon truc. Pourrais-tu développez ton dernier poste car je ne vois quelle est la différence et cela m'intéresse.