template & héritage
Le
gourdi
Bonjour,
j'ai un problème que je ne comprends pas : 2 classes templates
héritent d'une classe mère template, et les classes filles ne sembent
pas avoir accès aux variables membres de la classe mère.
Je suis perplexe, où me trompè-je? Merci pour votre aide.
Le code (le compilateur râle parce qu'il ne trouve pas '_points' dans
les classes filles) :
template <typename T>
class ggo_curve_abc
{
public:
virtual T evaluate(T x) const = 0;
protected:
std::vector<ggo_set2<T> > _points;
};
template <typename T>
class ggo_linear_curve : public ggo_curve_abc<T>
{
public:
virtual T evaluate(T x) const;
};
template <typename T>
class ggo_cubic_curve : public ggo_curve_abc<T>
{
public:
virtual T evaluate(T x) const;
};
template <typename T>
T ggo_linear_curve<T>::evaluate(T x) const
{
if (_points.size() < 2)
{
return T(0);
}
// <snip>
}
template <typename T>
T ggo_cubic_curve<T>::evaluate(T x) const
{
if (_points.size() < 4)
{
return T(0);
}
// <snip>
}
j'ai un problème que je ne comprends pas : 2 classes templates
héritent d'une classe mère template, et les classes filles ne sembent
pas avoir accès aux variables membres de la classe mère.
Je suis perplexe, où me trompè-je? Merci pour votre aide.
Le code (le compilateur râle parce qu'il ne trouve pas '_points' dans
les classes filles) :
template <typename T>
class ggo_curve_abc
{
public:
virtual T evaluate(T x) const = 0;
protected:
std::vector<ggo_set2<T> > _points;
};
template <typename T>
class ggo_linear_curve : public ggo_curve_abc<T>
{
public:
virtual T evaluate(T x) const;
};
template <typename T>
class ggo_cubic_curve : public ggo_curve_abc<T>
{
public:
virtual T evaluate(T x) const;
};
template <typename T>
T ggo_linear_curve<T>::evaluate(T x) const
{
if (_points.size() < 2)
{
return T(0);
}
// <snip>
}
template <typename T>
T ggo_cubic_curve<T>::evaluate(T x) const
{
if (_points.size() < 4)
{
return T(0);
}
// <snip>
}
En ajoutant this->, ce qui suit compile bien avec gcc (Gentoo 4.5.3-r2
p1.1, pie-0.4.7) 4.5.3, et s'éxécute bien.
Je suis également surpris que this-> soit nécesssaire…
------------------------------------------------------------------------
#include <vector>
template <typename T>
class ggo_set2
{
public:
ggo_set2(){}
};
template <typename T>
class ggo_curve_abc
{
public:
virtual T evaluate(T x) const = 0;
protected:
std::vector<ggo_set2<T> > _points;
};
template <typename T>
class ggo_linear_curve : public ggo_curve_abc<T>
{
public:
virtual T evaluate(T x) const;
};
template <typename T>
class ggo_cubic_curve : public ggo_curve_abc<T>
{
public:
virtual T evaluate(T x) const;
};
template <typename T>
T ggo_linear_curve<T>::evaluate(T x) const
{
if (this->_points.size() < 2)
{
return T(0);
}
// <snip>
}
template <typename T>
T ggo_cubic_curve<T>::evaluate(T x) const
{
if (this->_points.size() < 4)
{
return T(0);
}
// <snip>
}
int main(){
ggo_linear_curve<int> c;
c.evaluate(42);
return(0);
}
------------------------------------------------------------------------
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.
Pour plus de détails là -dessus, lire dans Effective C++ de Scot t Meyers :
Item 43 : Know how to access names in templatized base class
Quelle edition ? c'est pas l'Item 43 dans ma 2e edition, en tout cas.
Que dit Scott Meyers? (je n'ai pas accès à ce livre)
Merci.
C'est pas classes templates mais template de classe (autrement dit ce ne
sont pas des classes mais des templates pour faire des classes; les
instantiations sont bien des classes; en anglais dans "class template",
class est le qualicatif et template le nom qualifié; on a utilisé template
class -- qui se traduit bien par classe template -- pour ce qu'on appelle
maintenant instantiations, on a arrêté car la nuance entre class template
et template class est un peu trop subtile).
Les noms dans un template sont recherchés à deux moments différents suivant
leur sorte (keyword: two phases name lookup)
Ceux qui ne dépendent pas visiblement d'un paramètre du template sont
recherchés uniquement à la définition du template et ne peuvent *jamais*
trouver des définitions qui dépendent de la valeur d'un paramètre du
template.
Ceux qui dépendent visiblement de la définition d'un paramètre du template
sont recherchés à l'instantiation (et naturellement leur définition peut
dépendre de celui-ci)
Un nom comme _points ne dépend pas visiblement d'un paramètre template et
on ne va pas chercher les membres des classes de base qui sont des
instantiations avec des paramètres du template. this->_points rend le nom
dépendant et il est donc cherché à la définition.
A+
--
Jean-Marc
FAQ de fclc++: http://web.archive.org/web/*/http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
C'est le cas dans la troisième édition... pp. 207-212
non, c'est tout a fait normal.
Voir C++11 14.6.2 "Dependent names". Accessoirement la sous-section
"Dependent types" et suivantes expliquent pourquoi C++ a besoin de
typename par-ci par-la. La section 14.6 "Name resolution" a toujours
ete ma section preferee de C++ ;-)
a+,
laurent
C'est clair!
Merci.
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.
Oops, a l'instantiation et pas a la definition, et donc en utilisant
donc les parametres du template qui sont connus.
Un complement sur la cause.
D'une part, le mecanisme des specialisations explicites fait qu'on ne
peut reellement rien faire pour les noms dependant avant l'instantiation
(On ne sait pas que foo<T> a un membre _toto sans connaitre T parce
qu'il peut y avoir des specialisations explicites de foo qui n'en ont
pas).
On cherche les noms non dependant dans le contexte de definition plutot
que d'instantiation (ce qui serait possible et etait fait en pratique
avant qu'on ne definisse clairement le mecanisme de recherche; certains
compilateurs -- dont il me semble VC++ -- ont mis longtemps a etre
conforme sur ce point) parce que la recherche dans le contexte
d'instantiation trouve facilement des definitions inattendus. Avec
cette regle,
int foo;
template <typename T> struct S: T
{
void incfoo() { foo++; }
}
incremente systemantiquement la variable globale, et non la variable
globale quand T n'a pas de membre foo et le membre quand T en a un. On
le paie par une erreur et la necessite d'utiliser this->foo si on veut
le membre et qu'il n'y a pas de variable globale.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index. html
Site de usenet-fr: http://www.usenet-fr.news.eu.org