Logo GNT
Actualités Tests & Guides Bons Plans
Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11
Entraide Développement Développement Langage C++ template & héritage

template & héritage

9 réponses
Avatar
gourdi
Bonjour,

j'ai un probl=E8me que je ne comprends pas : 2 classes templates
h=E9ritent d'une classe m=E8re template, et les classes filles ne sembent
pas avoir acc=E8s aux variables membres de la classe m=E8re.

Je suis perplexe, o=F9 me tromp=E8-je? Merci pour votre aide.

Le code (le compilateur r=E2le 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 =3D 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>
}
Signaler un problème avec ce contenu

9 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Avatar
Pascal J. Bourguignon
writes:

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) :



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 {}.
Avatar
ptyxs
Le 22/05/2012 16:52, Pascal J. Bourguignon a écrit :
writes:

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 n e 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) :



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…




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
Avatar
espie
In article , ptyxs wrote:
Pour plus de détails là-dessus, lire dans Effective C++ de Scott 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.
Avatar
g.gourdin
Le mardi 22 mai 2012 17:15:20 UTC+2, ptyxs a écrit :
Le 22/05/2012 16:52, Pascal J. Bourguignon a écrit :
>
>> 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 semb ent
>> 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' dan s
>> les classes filles) :
>
> 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…
>

Pour plus de détails là-dessus, lire dans Effective C++ de Scott Meye rs :

Item 43 : Know how to access names in templatized base class



Que dit Scott Meyers? (je n'ai pas accès à ce livre)

Merci.
Avatar
Jean-Marc Bourguet
writes:

Bonjour,

j'ai un problème que je ne comprends pas : 2 classes templates



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

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.



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
Avatar
ptyxs
Le 22/05/2012 17:31, Marc Espie a écrit :
In article, ptyxs wrote:
Pour plus de détails là-dessus, lire dans Effective C++ de Scott M eyers :

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.



C'est le cas dans la troisième édition... pp. 207-212
Avatar
ld
On 22 mai, 16:52, "Pascal J. Bourguignon"
wrote:
writes:
> 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 sembe nt
> 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) :

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…



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


------------------------------------------------------------------------

#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 {}.
Avatar
Pascal J. Bourguignon
Jean-Marc Bourguet writes:

writes:

Bonjour,

j'ai un problème que je ne comprends pas : 2 classes templates



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

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.



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.



C'est clair!

Merci.
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.
Avatar
Jean-Marc Bourguet
"Pascal J. Bourguignon" writes:

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.



C'est clair!



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