Passage de paramètre par valeur ou par const référence ?

**Arzar** · 10/02/2009, 10h36

Pour la petite histoire, lors de ma dernière mission, je me souviens de la consternation générale lorsque l'équipe du visuel avait migré de vs2003 à vs2005 : les perfs s'était effondrées ! (De 60fps à 15fps à quand même!

)
Quelques heures de recherche plus tard, un coup de _HAS_ITERATOR_DEBUGGING=0 et_SECURE_SCL=0 et tout était rentré dans l'ordre. Faut dire que la STL était lourdement utilisé dans tout le moteur et la petite pénalité imposée par la version secure avait eu des répercussions en cascades.

Edit : deux autres petits trucs qui me reviennent sur le passage 2003-2005
* Quelques warning sont apparus, notamment sur les enum.
* Les nouveaux projets crées sous vs2005 utilisent par défaut l'encodage unicode(propriétés->général->caracter:use unicode caracter set au lieu de use multi-byte caracter set).

**camboui** · 16/02/2009, 11h16

"const ref" ou "valeur" ?
Finalement, les avis sont assez partagés pour les types que l'on pourrait croire léger (comme les pointeurs, et encore faut-il s'entendre sur la notion de "léger").

Un exemple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
std::vector<int> vi;
std::sort(vi.begin(),vi.end());
int i;
std::lower_bound(vi.begin(),vi.end(),i);

"i" est passé par référence à std::lower_bound() (c'est le cas dans les implémentations que j'ai regardé). C'est un peu dommage.
Est-ce qu'il y a une optimization des compilateurs pour détecter de genre de cas "simple" ?

Imaginons aussi un itérateur de ce genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class iterator
{
MaClasse & f_maclasse;
unsigned f_pos;
public:
iterator(MaClasse & maclasse):f_maclasse(maclasse),f_pos(0u) {}
iterator(const iterator & r):f_maclasse(r.f_maclasse),f_pos(r.f_pos) {}
//operator=(), etc
//operator +=, ++, -, etc, agissant sur f_pos uniquement
//operator*, et rien que lui, utilisant f_maclasse
};

Comment passeriez-vous ce genre de classe assez "légère" ?
Pour info, toutes les opérations des fonctions membres sont basiques, sauf operator*() qui peut être assez complexe mais elle n'intervient pas lors d'un passage de paramètre.

**Cheps** · 16/02/2009, 12h36

Personnellement, je passe systématiquement les types de base par valeur, et les objets par référence. Dans le cas d'un objet même très simple (même avec juste un membre int par exemple) je passe par référence, si plus tard je veux "alourdir" l'objet en rajoutant des choses je ne dois pas reparcourir tout mon code pour mettre des références.

Je pense qu'il faut vraiment avoir une application très très exigeante en termes de performances, ou alors bas niveau pour devoir se poser la question: "Si mon double est sur 2 octets, vaut-il mieux le passer par valeur ou par référence". Je commencerais par me demander si je dois utiliser un double ou un float bien avant de me soucier de comment le passer en paramètre.

**camboui** · 04/03/2009, 16h58

Envoyé par Arzar

...

Edit : deux autres petits trucs qui me reviennent sur le passage 2003-2005
* Quelques warning sont apparus, notamment sur les enum.
* Les nouveaux projets crées sous vs2005 utilisent par défaut l'encodage unicode(propriétés->général->caracter:use unicode caracter set au lieu de use multi-byte caracter set).

Il me semble qu'ils sont aussi multi-thread par défaut, non ?

**ram-0000** · 04/03/2009, 17h01

Envoyé par camboui

Il me semble qu'ils sont aussi multi-thread par défaut, non ?

Sous Visual Studio 2005, effectivement, les projets sont multi-thread par défaut (et aussi Unicode par défaut). Pour les versions antérieures, je ne me rappelle plus des valeurs par défaut.

**Médinoc** · 04/03/2009, 17h02

Pour être précis, ils utilisent par défaut la version DLL de la CRT (/MD).
Quant à la version statique mono-thread (/ML), elle n'existe plus.

**camboui** · 04/03/2009, 23h14

En regardant de plus près, il me semble qu'il n'y a même pas d'option mono-thread du tout !

**camboui** · 05/03/2009, 16h28

Pour en revenir à const, quelle est la différence entre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const T & v

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const & v

Autant pour les pointeurs il y a une grosse différence, autant pour les références je ne sais pas trop. Ce n'est que très récemment que j'ai découvert la deuxième écriture.

**koala01** · 05/03/2009, 16h34

Envoyé par camboui

Pour en revenir à const, quelle est la différence entre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const T & v

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const & v

Autant pour les pointeurs il y a une grosse différence, autant pour les références je ne sais pas trop. Ce n'est que très récemment que j'ai découvert la deuxième écriture.

Ce n'est que la différence entre se placer du point de vue de la règle générale (T const &) ou du point de vue de l'exception (const T &)...

En effet, la règle générale est

const s'applique à ce qui se trouve à sa gauche

et l'exception est

Sauf s'il n'y a rien à sa gauche, auquel cas, il s'applique à ce qui se trouve à sa droite

[EDIT]Les puristes préféreront donc souvent rester du coté de la règle générale

**Médinoc** · 05/03/2009, 16h34

Il n'y a aucune différence, ni pour les pointeurs, ni pour les références.

Tu confonds avec T * const.

Edit: Le lien que je cherchais : http://www.developpez.net/forums/d30...t/#post1914498

**camboui** · 05/03/2009, 16h55

Ah ok merci !
Je récapitule:
const T & == T const &
const T * == T const *
T * const != T const * (pointeur figé != valeur pointée figée)
T const * const (le pointeur et la valeur pointée sont "figés")
const T const * (ça veut rien dire)
T & const (ça veut rien dire)

**koala01** · 05/03/2009, 17h03

il manque juste const T * const == T const * const

mais c'est effectivement cela

Il faut "juste" se rappeler que le compilateur va évaluer les expressions de droite à gauche, ce qui peut amener à un jeu sympa

Pourrais tu exprimer de manière précise, complète et en bon francais le but des expressions suivantes ( toutes ne sont pas forcément admises

):

int i = 2;
int *p = &i;
int & ref = i;
int *& pref = p;
int &* autrepref = p;
++p;
++(*p);

**camboui** · 05/03/2009, 20h55

J'ai du mal avec la 5, un pointeur sur une référence. Pas de sens AMA.

**Médinoc** · 05/03/2009, 22h33

En effet, il me semble que c'est impossible.

**koala01** · 05/03/2009, 23h50

C'est effectivement impossible...

J'avais bien dit que tout n'était pas autorisé

D'ailleurs, si tu remplace les termes "pointeur" et "référence" par leur définition "basique" ("une variable contenant l'adresse à laquelle se trouve..." et "un alias de la variable qui/nommée") tu remarque tout de suite ce qui peut aller et ce qui ne va pas

**camboui** · 06/03/2009, 10h03

"autrepref est une variable contenant l'adresse à laquelle se trouve l'alias de la variable nommée p"

Ce qui se conçoit bien s'énonce clairement.
Et les mots pour le dire vous viennent aisément.