 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Christophe Lephay
Guest
|
 Posted: Thu Sep 11, 2003 11:04 pm Post subject: Re: Classes, template, compilation ou dynamique |
 |
|
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> a écrit dans le message de
news:3f60fb91$0$27605$626a54ce (AT) news (DOT) free.fr...
| Quote: | Mon copain, qui regarde derrière mon dos : ça m'énerve !!!!, me soutient
que
la résolution des appels de méthodes des classes est résolue en statique,
au
même titre que pour les templates.
Je lui affirme que c'est la différence entre ces deux technologies.
Un template est "résolu" à la compilation (adresse en fixe dans le code)
Une classe "trouve" l'adresse d'une méthode à l'éxecution, ce qui permet
notamment sa "serialization".
Merci de me dire que j'ai raison 
|
Tu as raison, mais lui aussi...
Tu as raison pour les fonctions virtuelles, mais pas pour les autres.
| Quote: | Merci de me dire comment le démontrer ...
|
base * object;
object = new derived1();
object->fonction();
delete object;
object = new derived2();
object->fonction();
Avec derived1 et derived2 des classes dérivées de base et fonction() une
fonction virtuelle.
les deux instructions object->fonction() étant les mêmes, l'appel est
nécessairement résolu de manière dynamique vu que ce ne sont pas les mêmes
fonctions qui sont appelées. C'est encore plus flagrant si l'appel a lieu
dans une boucle :
for( int i = 0; i < tableau.size(); ++i )
tableau[ i ]->fonction();
Dans ce cas, je vois mal comment une résolution statique pourrait appeler
des fonctions différentes selon la nature des objets auxquels on accède dans
le tableau.
Par contre, dans le cas où les fonctions ne sont pas virtuelles, la
résolution de l'appel est effectuée par le compilateur (de manière statique,
donc).
Chris
|
|
| Back to top |
|
 |
kanze@gabi-soft.fr
Guest
|
| Posted: Fri Sep 12, 2003 6:29 am Post subject: Re: Classes, template, compilation ou dynamique |
|
|
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> wrote
| Quote: | Mon copain, qui regarde derrière mon dos : ça m'énerve !!!!, me
soutient que la résolution des appels de méthodes des classes est
résolue en statique, au même titre que pour les templates. Je lui
affirme que c'est la différence entre ces deux technologies.
|
C'est cependant lui qui a raison. Il n'y a aucune différence entre une
instantiation d'un template et une classe ou une fonction non-templatée.
| Quote: | Un template est "résolu" à la compilation (adresse en fixe dans le
code) Une classe "trouve" l'adresse d'une méthode à l'éxecution, ce
qui permet notamment sa "serialization".
|
Ça dépend. La résolution dynamique ne s'applique qu'aux fonctions
virtuelles, et alors, elles s'appliquent que la classe soit un template
ou non. Les deux choses sont orthogonales.
Et qu'est-ce que la sérialisation a à voir là-dedans ?
--
James Kanze GABI Software mailto:kanze (AT) gabi-soft (DOT) 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
|
|
| Back to top |
|
|
Ignace
Guest
|
| Posted: Fri Sep 12, 2003 7:06 am Post subject: Re: Classes, template, compilation ou dynamique |
|
|
<kanze (AT) gabi-soft (DOT) fr> a écrit dans le message de news:
[email]d6652001.0309112229.2fce1504 (AT) posting (DOT) google.com[/email]...
| Quote: | "Ignace" <pasdadresse (AT) tropspame (DOT) desole> wrote in message
news:<3f60fb91$0$27605$626a54ce (AT) news (DOT) free.fr>...
Mon copain, qui regarde derrière mon dos : ça m'énerve !!!!, me
soutient que la résolution des appels de méthodes des classes est
résolue en statique, au même titre que pour les templates. Je lui
affirme que c'est la différence entre ces deux technologies.
C'est cependant lui qui a raison. Il n'y a aucune différence entre une
instantiation d'un template et une classe ou une fonction non-templatée.
Un template est "résolu" à la compilation (adresse en fixe dans le
code) Une classe "trouve" l'adresse d'une méthode à l'éxecution, ce
qui permet notamment sa "serialization".
Ça dépend. La résolution dynamique ne s'applique qu'aux fonctions
virtuelles, et alors, elles s'appliquent que la classe soit un template
ou non. Les deux choses sont orthogonales.
Et qu'est-ce que la sérialisation a à voir là-dedans ?
|
Bonjour
Comment un compilateur peut il "connaitre" la classe, et donc les méthodes,
d'un objet dérivé désérialisé ? (extrait d'un fichier par exemple)
L'extrait de code suivant fonctionne t'il ?
(pardon pour les erreurs de syntaxes,
ca fait un bout de temps que je n'ai pas codé) :
//***************************************
Ancetre *a; // Ancêtre des classes dérivées
//DeriveeAvecVirtuelle1 et
//DeriveeAvecVirtuelle2
if (random()>0.5) {
a=new(DeriveeAvecVirtuelle1())
}else {
a=new(DeriveeAvecVirtuelle2())
}
a->methodeVirtuelle(); //** Virtuelle1 ou virtuelle 2 ?
//** ici le compilateur ne connait pas l'adresse de
*methodeVirtuelle()*
//**il doit passer par la vmt. C'est ce que j'appelle une
"résolution dynamique"
//**le choix de la méthode est réalisé à l'éxecution...
//***************************************
Je suis d'accord que ce mécanisme peut être appliqué aux templates.
Mais il s'agit cependant d'une techno "objet", alors que les templates
permet
à mon sens le déploiement de "super macros" ou les types de données sont
transmis au préprocesseur (compilateur).
Merci de votre lecture
-- Ignace
|
|
| Back to top |
|
|
Christophe Lephay
Guest
|
| Posted: Fri Sep 12, 2003 11:09 am Post subject: Re: Classes, template, compilation ou dynamique |
|
|
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> a écrit dans le message de
news:3f616feb$0$20186$626a54ce (AT) news (DOT) free.fr...
| Quote: | kanze (AT) gabi-soft (DOT) fr> a écrit dans le message de news:
[email]d6652001.0309112229.2fce1504 (AT) posting (DOT) google.com[/email]...
Ça dépend. La résolution dynamique ne s'applique qu'aux fonctions
virtuelles, et alors, elles s'appliquent que la classe soit un template
ou non. Les deux choses sont orthogonales.
Comment un compilateur peut il "connaitre" la classe, et donc les
méthodes,
d'un objet dérivé désérialisé ? (extrait d'un fichier par exemple)
L'extrait de code suivant fonctionne t'il ?
(pardon pour les erreurs de syntaxes,
ca fait un bout de temps que je n'ai pas codé) :
//***************************************
Ancetre *a; // Ancêtre des classes dérivées
//DeriveeAvecVirtuelle1 et
//DeriveeAvecVirtuelle2
if (random()>0.5) {
a=new(DeriveeAvecVirtuelle1())
}else {
a=new(DeriveeAvecVirtuelle2())
}
a->methodeVirtuelle(); //** Virtuelle1 ou virtuelle 2 ?
//** ici le compilateur ne connait pas l'adresse de
*methodeVirtuelle()*
//**il doit passer par la vmt. C'est ce que j'appelle une
"résolution dynamique"
//**le choix de la méthode est réalisé à l'éxecution...
//***************************************
|
La résolution de l'appel est dynamique parce que methodeVirtuelle() est
virtuelle. Si elle ne l'était pas, ce serait Ancetre::methode() qui serait
appelée (résolution statique). Si tu le relis, c'est ce qu'a dit James.
| Quote: | Je suis d'accord que ce mécanisme peut être appliqué aux templates.
Mais il s'agit cependant d'une techno "objet", alors que les templates
permet
à mon sens le déploiement de "super macros" ou les types de données sont
transmis au préprocesseur (compilateur).
|
C'est une façon de voir. Une autre consite à inverser la cause et l'effet :
une forme de "super macros" permet la programmation générique (ou
templates). On peut voir l'aspect macro dans la nécessité de rendre la
définition visible au point d'instanciation. Cet ressemblance disparaitra le
jour où export sera opérationnel.
Chris
|
|
| Back to top |
|
|
kanze@gabi-soft.fr
Guest
|
| Posted: Fri Sep 12, 2003 1:51 pm Post subject: Re: Classes, template, compilation ou dynamique |
|
|
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> wrote
| Quote: | kanze (AT) gabi-soft (DOT) fr> a écrit dans le message de news:
[email]d6652001.0309112229.2fce1504 (AT) posting (DOT) google.com[/email]...
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> wrote in message
news:<3f60fb91$0$27605$626a54ce (AT) news (DOT) free.fr>...
Mon copain, qui regarde derrière mon dos : ça m'énerve !!!!, me
soutient que la résolution des appels de méthodes des classes est
résolue en statique, au même titre que pour les templates. Je lui
affirme que c'est la différence entre ces deux technologies.
C'est cependant lui qui a raison. Il n'y a aucune différence entre
une instantiation d'un template et une classe ou une fonction
non-templatée.
Un template est "résolu" à la compilation (adresse en fixe dans le
code) Une classe "trouve" l'adresse d'une méthode à l'éxecution,
ce qui permet notamment sa "serialization".
Ça dépend. La résolution dynamique ne s'applique qu'aux fonctions
virtuelles, et alors, elles s'appliquent que la classe soit un
template ou non. Les deux choses sont orthogonales.
Et qu'est-ce que la sérialisation a à voir là-dedans ?
Comment un compilateur peut il "connaitre" la classe, et donc les
méthodes, d'un objet dérivé désérialisé ? (extrait d'un fichier par
exemple)
|
Le C++ ne connaît pas la sérialisation et la désérialisation. On ne peut
pas lire une classe d'un fichier, au moins qu'on a écrit du code
soi-même pour le faire.
| Quote: | L'extrait de code suivant fonctionne t'il ?
|
Oui.
| Quote: | (pardon pour les erreurs de syntaxes,
ca fait un bout de temps que je n'ai pas codé) :
//***************************************
Ancetre *a; // Ancêtre des classes dérivées
//DeriveeAvecVirtuelle1 et
//DeriveeAvecVirtuelle2
if (random()>0.5) {
a=new(DeriveeAvecVirtuelle1())
}else {
a=new(DeriveeAvecVirtuelle2())
}
a->methodeVirtuelle(); //** Virtuelle1 ou virtuelle 2 ?
//** ici le compilateur ne connait pas l'adresse de *methodeVirtuelle()*
//**il doit passer par la vmt. C'est ce que j'appelle une "résolution dynamique"
//**le choix de la méthode est réalisé à l'éxecution...
|
Tout dépend. Si methodVirtuelle a été déclaré virtuelle dans Ancetre, le
compilateur utilise la résolution dynamique. Sinon, c'est la
methodVirtuelle d'Ancetre qui serait appelée.
Mais comme j'ai dit, c'est orthogonal aux templates -- même si Ancetre
et ses derivées sont des templates, c'est la résolution dynamique qui
sert dès que la fonction est déclarée virtuelle.
| Quote: | //***************************************
Je suis d'accord que ce mécanisme peut être appliqué aux templates.
Mais il s'agit cependant d'une techno "objet", alors que les templates
permet à mon sens le déploiement de "super macros" ou les types de
données sont transmis au préprocesseur (compilateur).
|
Ne dis pas aux fanas des templates que ce sont des "super-macros".
Sérieusement, ce sont deux techniques différentes, dont les champs
d'application ne se récouvrent pas énormement -- il y aurait très peu de
cas où tu aurais le choix entre l'un et l'autre. Si c'est vrai qu'on
parle parfois des templates comme un polymorphisme résolu lors de la
compilation (ce qu'ils sont), on s'en sert surtout pour faire enforcer
des prédicats sur le système de typage. Quand j'utilise quelque chose
comme std::vector< MaClasse >, ce qui m'intéresse surtout, c'est
d'empècher quelqu'un d'y mettre autre chose qu'un MyClass, pour que je
n'ai pas besoin de traiter le cas quand je lis quelque chose de la
collection.
--
James Kanze GABI Software mailto:kanze (AT) gabi-soft (DOT) 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
|
|
| Back to top |
|
|
Gabriel Dos Reis
Guest
|
| Posted: Fri Sep 12, 2003 1:56 pm Post subject: Re: Classes, template, compilation ou dynamique |
|
|
[email]kanze (AT) gabi-soft (DOT) fr[/email] writes:
| Quote: | Ne dis pas aux fanas des templates que ce sont des "super-macros".
|
en effet, ce sont des hyper-macros hygiéniques.
-- Gaby
|
|
| Back to top |
|
|
Ignace
Guest
|
| Posted: Fri Sep 12, 2003 7:50 pm Post subject: Re: Classes, template, compilation ou dynamique |
|
|
| Quote: | Le C++ ne connaît pas la sérialisation et la désérialisation. On ne peut
pas lire une classe d'un fichier, au moins qu'on a écrit du code
soi-même pour le faire.
|
Merci, l'abus de java va rend sourd (aussi).
Je "présupposais" (aie) que le mécanisme d'enfilage dans un flux était
résolu, à la main s'il le faut.
Je parle aussi pas bien le français que le c++
la std ne possède pas de méthode de sérialisation (ou équivalent) ?
Je l'ai connue toute petite (classlib, de Borland, c'est ça ?). Et puis, je
l'ai oubliée.
Bricolant en java, j'avais pensé qu'elle avait grandit aussi.
| Quote: | L'extrait de code suivant fonctionne t'il ?
Oui.
|
Merci
C'est ce que je voulais savoir. Pour moi, c'est bien un "lien dynamique".
| Quote: | Tout dépend. Si methodVirtuelle a été déclaré virtuelle dans Ancetre,
Oui, c'est pouquoi je l'ai appelée comme ça. |
| Quote: | le
compilateur utilise la résolution dynamique. Sinon, c'est la
methodVirtuelle d'Ancetre qui serait appelée.
|
| Quote: | Mais comme j'ai dit, c'est orthogonal aux templates -- même si Ancetre
et ses derivées sont des templates, c'est la résolution dynamique qui
sert dès que la fonction est déclarée virtuelle.
|
la déclaration "virtuelle" n'est pas propre au mécanisme des template.
Une macro ferait la même chose ?
| Quote: |
Ne dis pas aux fanas des templates que ce sont des "super-macros".
|
On m'a parlé d'intégristes. Je suis sûr qu'on a exagéré.
| Quote: | Sérieusement, ce sont deux techniques différentes, dont les champs
d'application ne se récouvrent pas énormement -- il y aurait très peu de
cas où tu aurais le choix entre l'un et l'autre. Si c'est vrai qu'on
parle parfois des templates comme un polymorphisme résolu lors de la
compilation (ce qu'ils sont), on s'en sert surtout pour faire enforcer
des prédicats sur le système de typage. Quand j'utilise quelque chose
comme std::vector< MaClasse >, ce qui m'intéresse surtout, c'est
d'empècher quelqu'un d'y mettre autre chose qu'un MyClass, pour que je
n'ai pas besoin de traiter le cas quand je lis quelque chose de la
collection.
|
Merci pour ces éclairages.
Je garde ma perception de "super macro"... Je pense que la ligature statique
aboutit à un code optimisé -pas d'indirection- par rapport aux appels de la
vmt. Donc plus rapide, mais pour moi un
vecteur(maClasse *)
(pardon syntaxe approximative, une "référence" à maClasse)
est aussi structuré que
vecteur<maClasse>
Merci de vous intéresser à un iconoclaste codeur.
-- Ignace
|
|
| Back to top |
|
|
Christophe Lephay
Guest
|
| Posted: Sat Sep 13, 2003 8:48 am Post subject: Re: Classes, template, compilation ou dynamique |
|
|
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> a écrit dans le message de
news:3f622374$0$13269$626a54ce (AT) news (DOT) free.fr...
| Quote: | Mais comme j'ai dit, c'est orthogonal aux templates -- même si Ancetre
et ses derivées sont des templates, c'est la résolution dynamique qui
sert dès que la fonction est déclarée virtuelle.
la déclaration "virtuelle" n'est pas propre au mécanisme des template.
|
Orthogonal veut dire que c'est indépendant des templates : tu peux avoir des
classes templates avec ou sans fonctions virtuelles de même que tu peux
avoir des classes non templates avec ou sans fonctions virtuelles.
| Quote: | Une macro ferait la même chose ?
|
La même chose que quoi ?
| Quote: | Je garde ma perception de "super macro"...
|
Mon point de vue des macros, c'est qu'elles sont sensées offrir une
commodité pour écrire quelque chose qui peut l'être sans les macros. De ce
point de vue, les templates offrent un certain nombre de fonctionnalités qui
ne sont pas remplaçable par d'autres éléments du langage. Mais selon la
définition de macro, on peut tout assimiler à des macros - voire la
discussion édifiante sur les sucres syntaxiques ;)
| Quote: | Je pense que la ligature statique
aboutit à un code optimisé -pas d'indirection- par rapport aux appels de
la
vmt. Donc plus rapide, mais pour moi un
|
Le code peut être *et* template *et* virtuel...
| Quote: | vecteur(maClasse *)
(pardon syntaxe approximative, une "référence" à maClasse)
est aussi structuré que
vecteur<maClasse
|
vecteur< maClasse * > est juste la syntaxe en C++ pour fournir un type en
paramètre tout en mettant en oeuvre le mécanisme de controle de types du
compilateur (controle statique, donc). Je ne suis pas trop certain de ce que
serait sensé faire vecteur( maClasse * ).
Chris
|
|
| Back to top |
|
|
James Kanze
Guest
|
| Posted: Sun Sep 14, 2003 3:55 pm Post subject: Re: Classes, template, compilation ou dynamique |
|
|
"Ignace" <pasdadresse (AT) tropspame (DOT) desole> writes:
| Quote: | Le C++ ne connaît pas la sérialisation et la
désérialisation. On ne peut pas lire une classe d'un
fichier, au moins qu'on a écrit du code soi-même pour le
faire.
Merci, l'abus de java va rend sourd (aussi). Je "présupposais"
(aie) que le mécanisme d'enfilage dans un flux était
résolu, à la main s'il le faut.
Je parle aussi pas bien le français que le c++
|
Ça ne fait rien. Les habitués ici sont très tolérants.
(N'étant pas francophone moi-même, j'ai eu l'occasion de
l'expérimenter aussi.)
| Quote: | la std ne possède pas de méthode de sérialisation (ou
équivalent) ?
|
Non. La raison, sans doute, c'est qu'on ne sait pas réelement
définir ce que ça veut dire de façon portable. Puisque tu as
l'air de connaître la sérialisation de Java, tu dois savoir ce que
je veux dire : ça a l'air bien, mais chaque fois qu'on veut s'en
servir, on se rend compte qu'elle ne fait pas vraiment ce qu'on veut, et
on est amené bien à l'implémenter à la main de toute
façon.
| Quote: | Je l'ai connue toute petite (classlib, de Borland,
c'est ça ?). Et puis, je l'ai oubliée. Bricolant en java,
j'avais pensé qu'elle avait grandit aussi.
L'extrait de code suivant fonctionne t'il ?
Oui.
Merci C'est ce que je voulais savoir. Pour moi, c'est bien un "lien
dynamique".
Tout dépend. Si methodVirtuelle a été déclaré
virtuelle dans Ancetre,
Oui, c'est pouquoi je l'ai appelée comme ça.
le compilateur utilise la résolution dynamique. Sinon, c'est
la methodVirtuelle d'Ancetre qui serait appelée.
Mais comme j'ai dit, c'est orthogonal aux templates -- même si
Ancetre et ses derivées sont des templates, c'est la
résolution dynamique qui sert dès que la fonction est
déclarée virtuelle.
la déclaration "virtuelle" n'est pas propre au mécanisme des
template. Une macro ferait la même chose ?
|
Non, justement. De même qu'une classe non-templatée peut contenir
des fonctions non-virtuelles (et dans la pratique, on constate que c'est
le cas prèsque toujours), une classe templatée peut contenir des
fonctions virtuelles.
Comme j'ai dit, les deux conceptes sont orthogonaux, et leurs champs
d'application sont différents.
| Quote: | Ne dis pas aux fanas des templates que ce sont des
"super-macros".
On m'a parlé d'intégristes. Je suis sûr qu'on a exagéré.
|
Chaque fois qu'on découvre une nouvelle technologie, il y a un
certain nombre qui veut abandonner toute l'ancienne. Même quand, et
c'est le cas ici, la nouvelle technologie s'adresse surtout aux
problèmes qu'on ne savait pas bien résoudre avec l'ancien, et que
les technologies sont complémentaires.
| Quote: | Sérieusement, ce sont deux techniques différentes, dont les
champs d'application ne se récouvrent pas énormement -- il y
aurait très peu de cas où tu aurais le choix entre l'un et
l'autre. Si c'est vrai qu'on parle parfois des templates comme un
polymorphisme résolu lors de la compilation (ce qu'ils sont),
on s'en sert surtout pour faire enforcer des prédicats sur le
système de typage. Quand j'utilise quelque chose comme
std::vector< MaClasse >, ce qui m'intéresse surtout, c'est
d'empècher quelqu'un d'y mettre autre chose qu'un MyClass, pour
que je n'ai pas besoin de traiter le cas quand je lis quelque
chose de la collection.
Merci pour ces éclairages. Je garde ma perception de "super
macro"... Je pense que la ligature statique aboutit à un code
optimisé -pas d'indirection- par rapport aux appels de la vmt.
Donc plus rapide, mais pour moi un
vecteur(maClasse *)
(pardon syntaxe approximative, une "référence" à maClasse)
est aussi structuré que
vecteur
|
Certainement. J'utilise le premier quand je veux un tableau de
pointeurs, et le seconde quand je veux un tableau d'objets:-).
Sérieusement, la plupart du temps que je veux un tableau de
pointeurs, c'est qu'il s'agit des objets « entité », qui ne
supportent pas la copie, et qui risque de contenir des fonctions
virtuelles. Tandis que la plupart du temps où il s'agit des types
à valeur, c'est bien un tableau d'objets que je veux.
--
James Kanze mailto:kanze (AT) gabi-soft (DOT) fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
|
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
