Discussion :

[MatRem]

Bonsoir,

J'ai un petit problème avec une architecture à base de template.
On dirait que je ne peut pas accéder aux membres protected, d'une classe de base dans une classe dérivée.

J'ai grandement simplifié le code pour en arriver là:

Code main.cpp :

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

1
2
3
4
5
6
7
8
#include <cstdlib>
#include "B.h"
 
int main(int argc, char * argv[])
{
	B<int> b;
	return EXIT_SUCCESS;
}

Code A.h :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#ifndef _A_H
#define _A_H
 
template<typename T>
class A
{
public:
	virtual ~A();
protected:
	T var;
};
 
#include "A.tpp"
 
#endif

Code A.tpp :

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

1
2
3
template<typename T>
A<T>::~A()
{}

Code B.h :

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
#ifndef _B_H
#define _B_H
 
#include "A.h"
 
template <typename T>
class B : public A<T>
{
public:
	B();
	virtual ~B();
};
 
#include "B.tpp"
 
#endif

Code B.tpp :

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

1
2
3
4
5
6
7
8
9
10
template<typename T>
B<T>::B()
{
	var = 0; //Problème ici
}

template<typename T>
B<T>::~B()
{
}

J'utilise g++ 4.1.2 et j'ai ce message d'erreur:

g++ -c -Wall -Werror -pedantic -pedantic-errors -O3 -std=c++98 main.cpp -o main.o
B.tpp: In constructor ‘B<T>::B()’:
B.tpp:4: error: ‘var’ was not declared in this scope
make: *** [main.o] Erreur 1

[Laurent Gomila]

Essaye avec this->var, je crois que c'est nécessaire avec les classes templates (au moins avec gcc).

[MatRem]

Merci .
Effectivement ça fonctionne, c'est pas dans la norme ça?

Ça m'amène à une autre question, existe-t-il un meilleur compilateur, multiplateforme et libre que g++?

[David Fleury]

Merci .
Effectivement ça fonctionne, c'est pas dans la norme ça?

Je crois que oui.
Vandervoode/Josuttis expliquent pourquoi dans leur bouquin "C++ templates" (9.4.2)

[MatRem]

Ha ok, très bien. Laurent avait l'air de dire que c'était une spécificité de g++.
J'ai honte de ne plus avoir eu confiance en g++

Est ce que quelqu'un connaît l'intérêt de ce point? (je ne possède malheureusement pas l'ouvrage que tu sites).

Sinon je vais regarder dans le Stroustrup s'il en fait mention.

[roulious]

On trouve aussi une explication sur le site de gcc. L'idée est que une spécialisation de A peut être déclarée après la déclaration de B, être utilisée par B et ne pas déclarer ta variable. Le compilo ne regarde donc pas dans la classe de base, mais dans le namespace englobant.

[Jean-Marc.Bourguet]

Est ce que quelqu'un connaît l'intérêt de ce point? (je ne possède malheureusement pas l'ouvrage que tu sites).

Le point en question est la recherche des noms en deux phases et est plus general que l'heritage de template.

Il permet d'avoir une meilleure predictabilite (seuls les noms dépendant explicitement d'un paramètre template en dépendent et ils en dépendent toujours, quelle que soit la valeur du parametre), eviter des cas de comportements indefinis (sans la recherche des noms en deux phases, on peut arriver facilement a des cas ou pour une instantiation donnee, un nom qui n'est pas dependant -- et donc cherche uniquement dans le contexte de la definition du template -- est resolu de maniere differente dans les differents contextes d'instantiation) et permettre la detection d'erreur pour tout ce qui ne depend pas des parametres template quand on voit la definition plutot qu'attendre une instantiation.

[Charlemagne]

Essaye avec this->var, je crois que c'est nécessaire avec les classes templates (au moins avec gcc).

Petite suggestion de ma part:
C'est plus pratique de déclarer une bonne fois pour toutes la variable dans la classe dérivée avec 'using' qui est là popur ça, plutôt que d'utiliser le pointeur 'this' à chaque utilisation.

Code :

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

1
2
3
4
5
6
7
8
9
template <typename T>
class B : public A<T>
{
  public:
     typedef A<T> base;
     using base::var;
 
...
};

[David Fleury]

Petite suggestion de ma part:
C'est plus pratique de déclarer une bonne fois pour toutes la variable dans la classe dérivée avec 'using' qui est là popur ça, plutôt que d'utiliser le pointeur 'this' à chaque utilisation.

Dans le livre que j'ai cité, il donne trois variations pour éviter les problèmes de template et name lookup.
Le using dont tu parles est la deuxième qui (si mes souvenirs sont bons) à le désavantage de désactiver la "virtualité".
Il y a une troisème variation que je ne me rappelle pas

[MatRem]

Merci pour toutes ces précisions . On dirait qu'on rentre dans le "compliqué" du c++ là. Il va falloir que je me trouve un bouquin spécial template.

pour koala: en effet j'avais un peu trop simplifié mon exemple, en fait var est initialisé avec un paramètre de type T du constructeur.

[Jean-Marc.Bourguet]

Merci pour toutes ces précisions . On dirait qu'on rentre dans le "compliqué" du c++ là. Il va falloir que je me trouve un bouquin spécial template.

Je conseille fortement celui de Josuttis et van de Voorde.

[Charlemagne]

Dans le livre que j'ai cité, il donne trois variations pour éviter les problèmes de template et name lookup.
Le using dont tu parles est la deuxième qui (si mes souvenirs sont bons) à le désavantage de désactiver la "virtualité".
Il y a une troisème variation que je ne me rappelle pas

Je comprends pas bien ce que tu entends par "désactiver la virtualité"? un petit exemple peut-être? en tout cas ça ne peut détruire la virtualité que pour les fonctions, ici c'est une variable.

Si tu retrouves la 3ème possibilité, je suis curieux.

[David Fleury]

Alors, voilà à ce que j'ai compris
variation 1 :

Code :

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

1
2
3
4
5
6
 
template<typename T>
struct Derived : public Base<T> {
 void fct() { this->basefield_ = 0; }
};
// le this permet de faire la résolution de nom à l'instantiation du template

variation 2:

Code :

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

1
2
3
4
5
6
7
 
template<typename T>
struct Derived : public Base<T> {
 void fct() { Base<T>::basefield_ = 0; }
};
// il semble que le nom qualifié désactive les appels virtuels (l'aide des gurus
// est la bienvenue sur ce point ;)

variation 3 :

Code :

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

1
2
3
4
5
6
7
8
 
template<typename T>
struct Derived : public Base<T> {
 using Base<T>::basefield_;
 void fct() { basefield_ = 0; }
};
// il peut y avoir des soucis pour qualifier comme il faut en cas d'héritage
// multiples

"C++ Templates" - The complete guide.
Vandevoorde/Josuttis.
un "must-have" pour essayer de comprendre les templates.