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.

[koala01]

Salut,

De plus, tu fais une hypothèse relativement hasardeuse en écrivant

Code :

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

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

Tu pars du principe que var sera d'office une valeur numérique mais, qu'en est il d'un code du genre de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <string>
class C
{
    public:
        C(){}
        ~C(){}
       (...)
    private:
        std::string name;
        (...)
};

Code :

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

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

Tu as différentes possibilités lorsque tu conçoit l'héritage d'une classe template, mais, si tu veux partir de l'hypothèse que la variable du type template est une variable numérique, il faut que tu aies indiqué la spécialisation du type au sein meme de la classe dans laquelle tu fais l'hypothèse

Ca peut prendre une forme proche de

Code :

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

1
2
3
4
5
 
class D:public A<int>
{
(...)
};

par exemple

[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.

[Charlemagne]

Bon OK.
La variation 2 est la syntaxe habituelle pour appeler la fonction voulue, et en ce sens ça "casse la virtualité" mais c'est bien l'effet voulu...
En général on s'en sert pour appeler la fonction virtuelle à partir de la surcharge de cette même fonction virtuelle.

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
struct A
{
  virtual void f() 
  {  
    // faire qqch 
  }
};
struct B : public A
{
  virtual void f()
  {
    A::f();
    // faire qqch en plus
  }
};

'using' n'est qu'un raccourci pour éviter d'écrire "classe_de_base::" en permanence.

C'est vrai que 'using' sert aussi mais plus rarement lors des héritages multiples (l'héritage multiple est rarement une bonne idée, à part parfois pour les interfaces...) pour lever l'ambiguïté si 2 fonctions/variables de classes mères ont le même nom.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A1
{
  int a;
};
struct A2
{
  int a;
};
struct B : public A1, public A2
{
  using A1::a; // si je ne précise rien alors utiliser A1::a
...
};

De toute façon la syntaxe "this->" ne saurait lever l'ambiguïté éventuelle, donc je préfère personnellement utiliser 'using' pour sa concision.

[adel_dz]

Le probleme, ici, est liee au "name lookup" (desole je ne sais comment cela s'appelle en francais). En utilsant l'expression this->Var l'exprssion devient qualifée (Qualified_id) et donc uniquement la classe B et ces bases sont considerees. Par contre pour un identificateur non qualifie le "scope" (ca aussi, j'ignore le terme en francais) est pris en consideration et la si le compilo trouve une variable nommee va dans l'espace de la classe B il n'ira pas voir plus loin et tentera d'utilser cette var.
desole si ce n'est pas tres claire. On me reproche tjrs de mal expliquer les choses.
a+

[Jean-Marc.Bourguet]

Le probleme, ici, est liee au "name lookup" (desole je ne sais comment cela s'appelle en francais). En utilsant l'expression this->Var l'exprssion devient qualifée (Qualified_id) et donc uniquement la classe B et ces bases sont considerees. Par contre pour un identificateur non qualifie le "scope" (ca aussi, j'ignore le terme en francais) est pris en consideration et la si le compilo trouve une variable nommee va dans l'espace de la classe B il n'ira pas voir plus loin et tentera d'utilser cette var.
desole si ce n'est pas tres claire. On me reproche tjrs de mal expliquer les choses.
a+

Ce n'est pas clair du tout, au point que je ne sais pas si c'est correct ou pas. Pour les traductions:

Name lookup -> recherche des noms
Scope -> portée