Soit un objet local :
SomeObject *so = new SomeObject;
Quel sera la différence en terme de performance entre les deux appels
suivants (effectués dans le scope de définition de so) :
funcpp(&so);
et :
funcrp(so);
Attention ! Ma question ne porte pas sur le style à adopter, cette
question est souvent débattue et je ne veux pas lancer un nouveau troll
là-dessus.
Elle porte sur l'aspect purement "performance", si on peut dire, car je
ne sais pas exactement ce qui peut se passer au niveau des variables
temporaires potentiellement créées ou pas par les compilos.
Merci d'avance à ceuw qui ont des lumières là-dessus !
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
Jean-Marc Bourguet
btzaf writes:
Quel sera la différence en terme de performance entre les deux appels suivants (effectués dans le scope de définition de so) : funcpp(&so); et : funcrp(so);
Beaucoup de chance qu'il n'y ait aucune difference. Sauf dans des cas particuliers ou le compilateur peut supprimer toute representation physique, tu peux considerer que les references sont implementees par des pointeurs dereferences automatiquement.
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
btzaf <btzaf@free.fr> writes:
Quel sera la différence en terme de performance entre les deux appels
suivants (effectués dans le scope de définition de so) :
funcpp(&so);
et :
funcrp(so);
Beaucoup de chance qu'il n'y ait aucune difference. Sauf dans des cas
particuliers ou le compilateur peut supprimer toute representation
physique, tu peux considerer que les references sont implementees par des
pointeurs dereferences automatiquement.
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
Quel sera la différence en terme de performance entre les deux appels suivants (effectués dans le scope de définition de so) : funcpp(&so); et : funcrp(so);
Beaucoup de chance qu'il n'y ait aucune difference. Sauf dans des cas particuliers ou le compilateur peut supprimer toute representation physique, tu peux considerer que les references sont implementees par des pointeurs dereferences automatiquement.
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
Michael DOUBEZ
btzaf a écrit :
Il y a des matins où on se réveille avec des questions bêtes... Soient les deux fonctions suivantes fonctionellement équivalentes :
void funcpp(SomeObject **p) {
assert(p); assert(*p);
(*p)->someMethod(); delete *p; *p = 0; }
void funcrp(int *&p) {
assert(p);
p->someMethod(); delete p; p = 0; }
Soit un objet local : SomeObject *so = new SomeObject;
Quel sera la différence en terme de performance entre les deux appels suivants (effectués dans le scope de définition de so) : funcpp(&so); et : funcrp(so);
1. ça dépends comment le compilateur gère les références. 2. il y a un assert en plus dans le cas **
Attention ! Ma question ne porte pas sur le style à adopter, cette question est souvent débattue et je ne veux pas lancer un nouveau troll là-dessus.
Il ne s'agit pas de stye mais de sémantique. objet** a la sémantique de 'entrée de pointeur de pointeur' objet*& a la sémantiqe de 'entrée/sortie de pointeur'
En pratique, je m'attends à ce qu'on puisse passer NULL à objet** mais, bien sûr, je vérifierait la doc :)
Elle porte sur l'aspect purement "performance", si on peut dire, car je ne sais pas exactement ce qui peut se passer au niveau des variables temporaires potentiellement créées ou pas par les compilos.
Comme tu le dit, ça va dépendre du compilateur: pour autant que je sache, le standard n'interdit pas à un compilateur de traiter les références comme des pointeurs. Je suppose que CFront transformait en pointeur.
Que ça ne t'empêche pas de dormir :)
-- Michael
btzaf a écrit :
Il y a des matins où on se réveille avec des questions bêtes... Soient
les deux fonctions suivantes fonctionellement équivalentes :
void funcpp(SomeObject **p)
{
assert(p);
assert(*p);
(*p)->someMethod();
delete *p;
*p = 0;
}
void funcrp(int *&p)
{
assert(p);
p->someMethod();
delete p;
p = 0;
}
Soit un objet local :
SomeObject *so = new SomeObject;
Quel sera la différence en terme de performance entre les deux appels
suivants (effectués dans le scope de définition de so) :
funcpp(&so);
et :
funcrp(so);
1. ça dépends comment le compilateur gère les références.
2. il y a un assert en plus dans le cas **
Attention ! Ma question ne porte pas sur le style à adopter, cette
question est souvent débattue et je ne veux pas lancer un nouveau troll
là-dessus.
Il ne s'agit pas de stye mais de sémantique.
objet** a la sémantique de 'entrée de pointeur de pointeur'
objet*& a la sémantiqe de 'entrée/sortie de pointeur'
En pratique, je m'attends à ce qu'on puisse passer NULL à objet** mais,
bien sûr, je vérifierait la doc :)
Elle porte sur l'aspect purement "performance", si on peut dire, car je
ne sais pas exactement ce qui peut se passer au niveau des variables
temporaires potentiellement créées ou pas par les compilos.
Comme tu le dit, ça va dépendre du compilateur: pour autant que je
sache, le standard n'interdit pas à un compilateur de traiter les
références comme des pointeurs. Je suppose que CFront transformait en
pointeur.
Il y a des matins où on se réveille avec des questions bêtes... Soient les deux fonctions suivantes fonctionellement équivalentes :
void funcpp(SomeObject **p) {
assert(p); assert(*p);
(*p)->someMethod(); delete *p; *p = 0; }
void funcrp(int *&p) {
assert(p);
p->someMethod(); delete p; p = 0; }
Soit un objet local : SomeObject *so = new SomeObject;
Quel sera la différence en terme de performance entre les deux appels suivants (effectués dans le scope de définition de so) : funcpp(&so); et : funcrp(so);
1. ça dépends comment le compilateur gère les références. 2. il y a un assert en plus dans le cas **
Attention ! Ma question ne porte pas sur le style à adopter, cette question est souvent débattue et je ne veux pas lancer un nouveau troll là-dessus.
Il ne s'agit pas de stye mais de sémantique. objet** a la sémantique de 'entrée de pointeur de pointeur' objet*& a la sémantiqe de 'entrée/sortie de pointeur'
En pratique, je m'attends à ce qu'on puisse passer NULL à objet** mais, bien sûr, je vérifierait la doc :)
Elle porte sur l'aspect purement "performance", si on peut dire, car je ne sais pas exactement ce qui peut se passer au niveau des variables temporaires potentiellement créées ou pas par les compilos.
Comme tu le dit, ça va dépendre du compilateur: pour autant que je sache, le standard n'interdit pas à un compilateur de traiter les références comme des pointeurs. Je suppose que CFront transformait en pointeur.
