Pr ne pas utiliser des if () else if() ... j'ai besoin d'utiliser un
tableau de pointeur de fonction.
Comment fait ton pour construir un tableau de pointeur de fonction qui
pointe vers des methodes d'une classe ?
"Le Géant Vert" wrote in message news:<br79l9$6mb$...
"Benoit Rousseau" a écrit dans le message de news: 3fd6e74f$0$300$
wrote:
sentenza wrote in message news:<3fd5d94d$0$6970$...
template<typename T> class MaClass { [...]
} - Il faut que toutes les fonctions aient la même signature : tu
ne peux pas initialiser un « void (MaClass::*)() » avec &MaClass::Add, parce que &MaClass::Add a le type « void (MaClass::*)( T& ) ». La raison en est simple : comment est-ce que tu compte utiliser le pointeur ? Si tu as : void (MaClass<int>::*f)() = &MaClass<int>::Pop ; il faut écrire : (p->*f)() ; sans paramètre. Si tu as : void (MaClass<int>::*f)( int& ) = &MaClass<int>::Add ; il faut écrire : (p->*f)( 42 ) ;
Ca marche ça ? Il me semble avoir lu qu'on ne pouvait appeler que les membres statiques de cette façon.
m'est avis que si la méthode était statique, on pourrait se contenter d'un : (*f)(42); hors là on fait bien un : (p->*f)(42)
Si la fonction est statique, le type de son adresse est : void (*)(), et non void (NomDeClasse::*)(). Donc :
MaClasse* p ; void (MaClasse::*pmf)() = &MaClasse::functionNonStatique ; (p->*pmf)() ;
Sans les pointeurs, on peut bien écrire :
p->fonctionStatique() ;
Avec les pointeurs, c'est impossible, et la raison en est simple : une fonction statique s'appelle comme une fonction libre, sans pointeur de this. Une fonction non statique s'appelle avec un pointeur this. La séquence de l'appel est donc différent. Si j'écris p->fonctionStatique(), le compilateur voit que c'est une fonction statique, et ne passe pas de pointeur this, même s'il en a un.
Si je travaille avec des pointeurs à des fonctions, une fois que j'aurais affecté &MaClasse::fonctionStatique à un void (MaClasse::*)(), le compilateur ne peut plus savoir que la fonction est statique lors de l'appel. Il génère donc la séquence de l'appel des fonctions non-statiques ; au moins sur ma machine, ça ne va pas marcher.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Le Géant Vert" <_NOSPAM_legeantvert@tiscali.fr> wrote in message
news:<br79l9$6mb$1@news.tiscali.fr>...
"Benoit Rousseau" <not.provided@no.spam> a écrit dans le message de
news: 3fd6e74f$0$300$ba620e4c@reader5.news.skynet.be...
kanze@gabi-soft.fr wrote:
sentenza <sentenza9@club-internet.fr> wrote in message
news:<3fd5d94d$0$6970$7a628cd7@news.club-internet.fr>...
template<typename T>
class MaClass
{
[...]
}
- Il faut que toutes les fonctions aient la même signature : tu
ne peux pas initialiser un « void (MaClass::*)() » avec
&MaClass::Add, parce que &MaClass::Add a le type « void
(MaClass::*)( T& ) ». La raison en est simple : comment est-ce
que tu compte utiliser le pointeur ? Si tu as :
void (MaClass<int>::*f)() = &MaClass<int>::Pop ;
il faut écrire :
(p->*f)() ;
sans paramètre. Si tu as :
void (MaClass<int>::*f)( int& ) = &MaClass<int>::Add ;
il faut écrire :
(p->*f)( 42 ) ;
Ca marche ça ? Il me semble avoir lu qu'on ne pouvait appeler que
les membres statiques de cette façon.
m'est avis que si la méthode était statique, on pourrait se contenter
d'un : (*f)(42);
hors là on fait bien un :
(p->*f)(42)
Si la fonction est statique, le type de son adresse est : void (*)(), et
non void (NomDeClasse::*)(). Donc :
MaClasse* p ;
void (MaClasse::*pmf)() = &MaClasse::functionNonStatique ;
(p->*pmf)() ;
Sans les pointeurs, on peut bien écrire :
p->fonctionStatique() ;
Avec les pointeurs, c'est impossible, et la raison en est simple : une
fonction statique s'appelle comme une fonction libre, sans pointeur de
this. Une fonction non statique s'appelle avec un pointeur this. La
séquence de l'appel est donc différent. Si j'écris
p->fonctionStatique(), le compilateur voit que c'est une fonction
statique, et ne passe pas de pointeur this, même s'il en a un.
Si je travaille avec des pointeurs à des fonctions, une fois que
j'aurais affecté &MaClasse::fonctionStatique à un void (MaClasse::*)(),
le compilateur ne peut plus savoir que la fonction est statique lors de
l'appel. Il génère donc la séquence de l'appel des fonctions
non-statiques ; au moins sur ma machine, ça ne va pas marcher.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
"Le Géant Vert" wrote in message news:<br79l9$6mb$...
"Benoit Rousseau" a écrit dans le message de news: 3fd6e74f$0$300$
wrote:
sentenza wrote in message news:<3fd5d94d$0$6970$...
template<typename T> class MaClass { [...]
} - Il faut que toutes les fonctions aient la même signature : tu
ne peux pas initialiser un « void (MaClass::*)() » avec &MaClass::Add, parce que &MaClass::Add a le type « void (MaClass::*)( T& ) ». La raison en est simple : comment est-ce que tu compte utiliser le pointeur ? Si tu as : void (MaClass<int>::*f)() = &MaClass<int>::Pop ; il faut écrire : (p->*f)() ; sans paramètre. Si tu as : void (MaClass<int>::*f)( int& ) = &MaClass<int>::Add ; il faut écrire : (p->*f)( 42 ) ;
Ca marche ça ? Il me semble avoir lu qu'on ne pouvait appeler que les membres statiques de cette façon.
m'est avis que si la méthode était statique, on pourrait se contenter d'un : (*f)(42); hors là on fait bien un : (p->*f)(42)
Si la fonction est statique, le type de son adresse est : void (*)(), et non void (NomDeClasse::*)(). Donc :
MaClasse* p ; void (MaClasse::*pmf)() = &MaClasse::functionNonStatique ; (p->*pmf)() ;
Sans les pointeurs, on peut bien écrire :
p->fonctionStatique() ;
Avec les pointeurs, c'est impossible, et la raison en est simple : une fonction statique s'appelle comme une fonction libre, sans pointeur de this. Une fonction non statique s'appelle avec un pointeur this. La séquence de l'appel est donc différent. Si j'écris p->fonctionStatique(), le compilateur voit que c'est une fonction statique, et ne passe pas de pointeur this, même s'il en a un.
Si je travaille avec des pointeurs à des fonctions, une fois que j'aurais affecté &MaClasse::fonctionStatique à un void (MaClasse::*)(), le compilateur ne peut plus savoir que la fonction est statique lors de l'appel. Il génère donc la séquence de l'appel des fonctions non-statiques ; au moins sur ma machine, ça ne va pas marcher.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
