Discussion :

[camboui]

En régle générale, je suppose qu'il vaut mieux passer des objets "lourds" en paramètre de fonction par référence. Mais n'y-a-t-il pas des cas où c'est mieux de les passer par valeur ? (dans les deux cas je pense à un usage read only)

Par exemple, il me semble inutile de passer un int par référence (ou tout type de base). Mais quid pour des objets légers comme un smart pointer ou l'habituel std::string ?

Dans le cas du smart pointer par exemple, le passage par valeur va induire une copie (avec incrémentation dans le cas d'un shared_ptr par exemple) bien souvent inutile. Le passage par référence, lui, va provoquer une indirection supplémentaire à chaque accès à un des membres de l'objet pointé.
En général je passe les paramètres par const référence la plupart du temps, mais je doute que se soit toujours le plus efficace.

Merci.

[white_tentacle]

Il me semble qu'il est vaguement admis qu'un passage par référence ne se justifie pas pour un objet d'une taille de < 8 ou 12 octets, mais qu'au-delà, on gagne à passer par référence constante.

Typiquement, un std::string doit être passé par référence constante.

Pour le shared_ptr, ce n'est plus tout à fait pareil. Si tu le passe par copie, tu peux modifier l'objet pointé, si tu le passe par référence constante, tu ne peux plus. Tu as une différence de sémantique, en plus de la problématique de performance.

[Médinoc]

Pour le shared_ptr, [...] si tu le passe par référence constante, tu ne peux plus.

Es-tu sûr de ça?
Car ça me parait beaucoup trop facile à casser pour être un mécanisme de const-correctness...

[white_tentacle]

Es-tu sûr de ça?
Car ça me parait beaucoup trop facile à casser pour être un mécanisme de const-correctness...

Après vérification... Tu as raison

Du coup... Avant, je faisais :

Code :

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

1
2
int f(const T* const param)
{ ... }

Je fais comment avec un smart pointer ?

[Médinoc]

Généralement, les smart pointers qui supportent la const-correctness permettent ceci:

Code C++ :

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

1
2
3
4
5
6
7
int f(shared_ptr< const T > param);
 
int main(void)
{
	shared_ptr< T > spObj(new T());
	return f(spObj);
}

C'est sans doute la raison pour laquelle le standard C++ autorise le delete sur un pointeur const: Pour les cas où le dernier pointeur est un pointeur const...

[koala01]

Salut,

Je vais avoir une réponse de normand, mais...

Pour moi, dés le moment où tu veux passer autre chose qu'un type primitif en argument, il y a lieu de le passer sous la forme d'une référence (constante si la fonction ne doit pas le modifier).

Il ne me semble pas opportun de s'inquiéter de "l'efficacité" du procédé tant que tu n'a pas la preuve (grâce à un profiling complet) que cela occasion un "goulot d'étranglement".

Et, même si l'utilisation d'une référence constante est mise en évidence dans un goulot d'étranglement, il me semble bien plus opportun de s'assurer de l'efficacité "optimale" de l'algorithme qui le provoque avant d'aller chercher du côté de celle de l'efficacité de la référence constante.

Ce ne sera vraiment que lorsque tu aura la certitude de ne plus pouvoir améliorer l'algorithme et pour autant que tu remarque encore (profiling à l'appuis) qu'il est encore nécessaire d'améliorer les choses qu'il sera alors temps de s'inquiéter de cette référence (constante ou non)