Perf références // pointeurs

Le
btzaf
Bonjour,

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)
{
(*p)->someMethod();
delete *p;
*p = 0;
}

void funcrp(int *&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);

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 !

Cordialement,

btzaf
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Jean-Marc Bourguet
Le #18169531
btzaf
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
Le #18169521
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
Publicité
Poster une réponse
Anonyme