Bonjour,
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le code, c'est
l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas appel
virtuel, mais j'avoue ne pas savoir si ce passage est suffisant ou même
approprié.
Merci,
Bonjour,
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le code, c'est
l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas appel
virtuel, mais j'avoue ne pas savoir si ce passage est suffisant ou même
approprié.
Merci,
Bonjour,
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le code, c'est
l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas appel
virtuel, mais j'avoue ne pas savoir si ce passage est suffisant ou même
approprié.
Merci,
Bonjour,
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
(b->*fct)();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le code, c'est
l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant. Le
10.3.12 Explicit qualification with the scope operator (5.1) suppresses
the virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas appel
virtuel, mais j'avoue ne pas savoir si ce passage est suffisant ou même
approprié.
Bonjour,
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
(b->*fct)();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le code, c'est
l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant. Le
10.3.12 Explicit qualification with the scope operator (5.1) suppresses
the virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas appel
virtuel, mais j'avoue ne pas savoir si ce passage est suffisant ou même
approprié.
Bonjour,
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
(b->*fct)();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le code, c'est
l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant. Le
10.3.12 Explicit qualification with the scope operator (5.1) suppresses
the virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas appel
virtuel, mais j'avoue ne pas savoir si ce passage est suffisant ou même
approprié.
Trace la fonction f dans A et dans B et puis appelle la par un pointeur
et tu sera.
FctPtr fct = &A::f;
b->*fct();
C'est quoi *fct()??? Il faut peut être la déclarer avant de l'appeler!!!
Trace la fonction f dans A et dans B et puis appelle la par un pointeur
et tu sera.
FctPtr fct = &A::f;
b->*fct();
C'est quoi *fct()??? Il faut peut être la déclarer avant de l'appeler!!!
Trace la fonction f dans A et dans B et puis appelle la par un pointeur
et tu sera.
FctPtr fct = &A::f;
b->*fct();
C'est quoi *fct()??? Il faut peut être la déclarer avant de l'appeler!!!
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
C'est quoi *fct()???
Il faut peut être la déclarer avant de l'appeler!!!
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
C'est quoi *fct()???
Il faut peut être la déclarer avant de l'appeler!!!
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
C'est quoi *fct()???
Il faut peut être la déclarer avant de l'appeler!!!
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le
code, c'est l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas
appel virtuel, mais j'avoue ne pas savoir si ce passage est
suffisant ou même approprié.
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le
code, c'est l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas
appel virtuel, mais j'avoue ne pas savoir si ce passage est
suffisant ou même approprié.
Soit le cas suivant :
struct A
{
virtual void f();
};
struct B : A
{
virtual void f();
}
typedef void (A::*FctPtr)();
FctPtr fct = &A::f;
int main()
{
A *b = new B;
b->*fct();
}
(désolé s'il y a des fautes de frappes, j'ai pas compilé le
code, c'est l'idée qui compte)
Dans ce cas, quelle fonction est appelée : A::f ou B::f ?
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
Me fait penser que comme on a explicité A::f, il n'y aura pas
appel virtuel, mais j'avoue ne pas savoir si ce passage est
suffisant ou même approprié.
Il y manque des parenthèses : ce que tu a écris est
l'équivalent de « b->*(fct()) », c-à-d qu'il appellerait une
fonction libre fct, qui doit renvoyer un pointeur à membre, et
puis accéderait au membre désigné (pour ne rien faire avec lui)
de l'objet désigné par b.
Essaie « (b->*fct)() ».
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
§10.3/13 (au moins dans la version de travail le plus récente)
ne parle que vaguement des appels directs. Où il faut chercher,
c'est dans la section 5, sur la signification des expressions.
Surtout §5.2.2/1 (vers la fin) : « The function called in a
member function call is normally selected according to the
static type of the object expression (clause 10), but if that
function is virtual and is not specified using a qualified id
then the function actually called will be the final overrider
(10.3) of the selected function in the dynamic type of the
object expression ». Or, ici, la fonction est spécifiée au
moyen d'un pointeur à membre, qui n'est pas une « qualified
id ».
Si tu as l'occasion de régarder dans l'ARM, Stroustrup y propose
une implémentation possible, qui correspond d'assez près à celle
utiliser dans CFront (et encore dans VC++, je crois) : un
pointeur à une function membre est en fait une structure, qui
contient l'information si la fonction est virtuelle ou non, et
le cas échéant, soi son adresse réele, soi l'indice de son
entrée dans le vtable. (L'autre implémentation que je connais,
c'est de générer un trampoline, c-à-d une fonction sans nom qui
ressemble à une fonction membre non-virtuelle de A, et qui
appelle la fonction en question, et de mettre l'adresse du
trampoline dans le pointeur. C'est celui qui sert aujourd'hui
dans g++ et dans Sun CC.)
En passant, c'est intéressant à noter qu'avec des pointeurs au
membre, on a même une forme assez restreinte de la virtualité
pour les données :
struct A {} ;
struct B : A { int i ; } ;
int A::*pi = static_cast< int A::* >( &B::i ) ;
void
f( A* p )
{
std::cout << p->*pi ;
}
C'est légal, et ça marche, dans la mesure où l'objet désigné par
p a réelement un type dynamique B (ou quelque chose qui dérive
de B -- et je crois qu'il y a des restrictions dans le cas des
dérivations virtuelles).
Il y manque des parenthèses : ce que tu a écris est
l'équivalent de « b->*(fct()) », c-à-d qu'il appellerait une
fonction libre fct, qui doit renvoyer un pointeur à membre, et
puis accéderait au membre désigné (pour ne rien faire avec lui)
de l'objet désigné par b.
Essaie « (b->*fct)() ».
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
§10.3/13 (au moins dans la version de travail le plus récente)
ne parle que vaguement des appels directs. Où il faut chercher,
c'est dans la section 5, sur la signification des expressions.
Surtout §5.2.2/1 (vers la fin) : « The function called in a
member function call is normally selected according to the
static type of the object expression (clause 10), but if that
function is virtual and is not specified using a qualified id
then the function actually called will be the final overrider
(10.3) of the selected function in the dynamic type of the
object expression ». Or, ici, la fonction est spécifiée au
moyen d'un pointeur à membre, qui n'est pas une « qualified
id ».
Si tu as l'occasion de régarder dans l'ARM, Stroustrup y propose
une implémentation possible, qui correspond d'assez près à celle
utiliser dans CFront (et encore dans VC++, je crois) : un
pointeur à une function membre est en fait une structure, qui
contient l'information si la fonction est virtuelle ou non, et
le cas échéant, soi son adresse réele, soi l'indice de son
entrée dans le vtable. (L'autre implémentation que je connais,
c'est de générer un trampoline, c-à-d une fonction sans nom qui
ressemble à une fonction membre non-virtuelle de A, et qui
appelle la fonction en question, et de mettre l'adresse du
trampoline dans le pointeur. C'est celui qui sert aujourd'hui
dans g++ et dans Sun CC.)
En passant, c'est intéressant à noter qu'avec des pointeurs au
membre, on a même une forme assez restreinte de la virtualité
pour les données :
struct A {} ;
struct B : A { int i ; } ;
int A::*pi = static_cast< int A::* >( &B::i ) ;
void
f( A* p )
{
std::cout << p->*pi ;
}
C'est légal, et ça marche, dans la mesure où l'objet désigné par
p a réelement un type dynamique B (ou quelque chose qui dérive
de B -- et je crois qu'il y a des restrictions dans le cas des
dérivations virtuelles).
Il y manque des parenthèses : ce que tu a écris est
l'équivalent de « b->*(fct()) », c-à-d qu'il appellerait une
fonction libre fct, qui doit renvoyer un pointeur à membre, et
puis accéderait au membre désigné (pour ne rien faire avec lui)
de l'objet désigné par b.
Essaie « (b->*fct)() ».
J'ai cherché dans la norme sans rien trouver de bien convainquant.
Le 10.3.12
Explicit qualification with the scope operator (5.1) suppresses the
virtual call mechanism.
§10.3/13 (au moins dans la version de travail le plus récente)
ne parle que vaguement des appels directs. Où il faut chercher,
c'est dans la section 5, sur la signification des expressions.
Surtout §5.2.2/1 (vers la fin) : « The function called in a
member function call is normally selected according to the
static type of the object expression (clause 10), but if that
function is virtual and is not specified using a qualified id
then the function actually called will be the final overrider
(10.3) of the selected function in the dynamic type of the
object expression ». Or, ici, la fonction est spécifiée au
moyen d'un pointeur à membre, qui n'est pas une « qualified
id ».
Si tu as l'occasion de régarder dans l'ARM, Stroustrup y propose
une implémentation possible, qui correspond d'assez près à celle
utiliser dans CFront (et encore dans VC++, je crois) : un
pointeur à une function membre est en fait une structure, qui
contient l'information si la fonction est virtuelle ou non, et
le cas échéant, soi son adresse réele, soi l'indice de son
entrée dans le vtable. (L'autre implémentation que je connais,
c'est de générer un trampoline, c-à-d une fonction sans nom qui
ressemble à une fonction membre non-virtuelle de A, et qui
appelle la fonction en question, et de mettre l'adresse du
trampoline dans le pointeur. C'est celui qui sert aujourd'hui
dans g++ et dans Sun CC.)
En passant, c'est intéressant à noter qu'avec des pointeurs au
membre, on a même une forme assez restreinte de la virtualité
pour les données :
struct A {} ;
struct B : A { int i ; } ;
int A::*pi = static_cast< int A::* >( &B::i ) ;
void
f( A* p )
{
std::cout << p->*pi ;
}
C'est légal, et ça marche, dans la mesure où l'objet désigné par
p a réelement un type dynamique B (ou quelque chose qui dérive
de B -- et je crois qu'il y a des restrictions dans le cas des
dérivations virtuelles).
En passant, c'est intéressant à noter qu'avec des pointeurs au
membre, on a même une forme assez restreinte de la virtualité
pour les données :
struct A {} ;
struct B : A { int i ; } ;
int A::*pi = static_cast< int A::* >( &B::i ) ;
void
f( A* p )
{
std::cout << p->*pi ;
}
C'est légal, et ça marche, dans la mesure où l'objet désigné par
p a réelement un type dynamique B (ou quelque chose qui dérive
de B -- et je crois qu'il y a des restrictions dans le cas des
dérivations virtuelles).
As-tu déjà rencontré des cas concrets où ce genre de chose étai t utilisé ?
En passant, c'est intéressant à noter qu'avec des pointeurs au
membre, on a même une forme assez restreinte de la virtualité
pour les données :
struct A {} ;
struct B : A { int i ; } ;
int A::*pi = static_cast< int A::* >( &B::i ) ;
void
f( A* p )
{
std::cout << p->*pi ;
}
C'est légal, et ça marche, dans la mesure où l'objet désigné par
p a réelement un type dynamique B (ou quelque chose qui dérive
de B -- et je crois qu'il y a des restrictions dans le cas des
dérivations virtuelles).
As-tu déjà rencontré des cas concrets où ce genre de chose étai t utilisé ?
En passant, c'est intéressant à noter qu'avec des pointeurs au
membre, on a même une forme assez restreinte de la virtualité
pour les données :
struct A {} ;
struct B : A { int i ; } ;
int A::*pi = static_cast< int A::* >( &B::i ) ;
void
f( A* p )
{
std::cout << p->*pi ;
}
C'est légal, et ça marche, dans la mesure où l'objet désigné par
p a réelement un type dynamique B (ou quelque chose qui dérive
de B -- et je crois qu'il y a des restrictions dans le cas des
dérivations virtuelles).
As-tu déjà rencontré des cas concrets où ce genre de chose étai t utilisé ?
