Est-il mieux en C++ pour le passage par valeur ou de passer par une référence constante?

Je me demande ce qui est mieux que la pratique. Je me rends compte que passer par une constante référence, devrait fournir de meilleures performances dans le programme parce que vous n'êtes pas de faire une copie de la variable.

connexes: stackoverflow.com/questions/2139224/...

InformationsquelleAutor Matt Pascoe | 2008-11-06

c++constants pass-by-reference pass-by-value variables

189

Il utilisé pour être généralement conseillée¹ de utilisation passe par const ref pour tous les types, sauf pour builtin types (char, int, double, etc.), pour les itérateurs et de la fonction des objets (lambdas, des classes dérivant de std::*_function).

Cela était particulièrement vrai avant l'existence de sémantique de déplacement. La raison en est simple: si vous avez passé par valeur, une copie de l'objet a dû être faite et, sauf pour les très petits objets, c'est toujours plus cher que de passer une référence.

Avec C++11, nous avons gagné la sémantique de déplacement. En un mot, la sémantique de déplacement, de séjour que, dans certains cas, un objet peut être passé “par la valeur” sans le copier. C'est en particulier le cas lorsque l'objet que vous êtes de passage est un rvalue.

En lui-même, le déplacement d'un objet est toujours au moins aussi cher que le passage par référence. Cependant, dans de nombreux cas, une fonction interne de la copie d'un objet, en tout cas — à savoir qu'il prendra propriété de l'argument.²

Dans ces situations, nous avons les éléments suivants (simplifié) trade-off:
1. Nous pouvons passer de l'objet par référence, puis à le copier en interne.
2. Nous pouvons passer de l'objet par valeur.
“Passage par valeur” provoque toujours l'objet à copier, sauf si l'objet est une rvalue. Dans le cas d'une rvalue, l'objet peut être déplacé à la place, alors que le deuxième cas est tout à coup plus “copier, puis de les déplacer”, mais “déplacer, puis (éventuellement) de se déplacer à nouveau”.

Pour les grands objets qui mettent en œuvre correcte des constructeurs de déplacement (comme les vecteurs, chaînes ...), le second cas est alors très plus efficace que la première. Par conséquent, il est recommandé de utiliser le passage par valeur si la fonction prend possession de l'argument, et si le type d'objet prend en charge efficace de déplacer.

Une note historique:

En fait, toute moderne compilateur doit être en mesure de comprendre lors du passage par valeur est cher, et de convertir implicitement l'appel à l'utilisation const ref si possible.

En théorie. Dans la pratique, les compilateurs ne peut pas toujours changer cela sans casser la fonction de l'interface binaire. Dans certains cas particuliers (lorsque la fonction est insérée) la copie sera effectivement ramené si le compilateur peut déterminer que l'objet d'origine ne sera pas changé à travers les actions dans la fonction.

Mais en général, le compilateur ne peut pas le déterminer, et l'avènement de la sémantique de déplacement dans le C++ a fait de cette optimisation, beaucoup moins.

¹ E. g. dans Scott Meyers, Effective C++.

² C'est en particulier souvent le cas pour objet les constructeurs, qui peuvent prendre des arguments et de les stocker en interne pour faire partie de la construction de l'objet d'état.
- hmmm... je ne suis pas sûr qu'il vaut la peine de passer par la réf. double-s
- Comme d'habitude, de stimuler l'aide ici. boost.org/doc/libs/1_37_0/libs/utility/call_traits.htm a modèle de choses automatiquement la figure quand un type est une interface de type (utile pour les modèles, où vous ne peut pas savoir qu'facilement).
- Cette réponse manque un point important. Pour éviter de découpage, vous devez passer par référence (const ou autre). Voir stackoverflow.com/questions/274626/...
- la droite. J'ai quitté la partie entière de polymorphisme parce que c'est tout à fait différente de la sémantique. Je crois que l'OP (sémantiquement) signifiait “par la valeur” argument de passage. Lorsque d'autres sémantique est nécessaire, la question n'a même pas de poser lui-même.
InformationsquelleAutor Konrad Rudolph
95

Edit: Nouvel article par david Abrahams sur les prestations du rpc-suivant:

Souhaitez vitesse? Le passage par valeur.

Passage par valeur pour les structures où la copie est bon marché a l'avantage supplémentaire que le compilateur peut supposer que les objets ne sont pas d'alias (ne sont pas les mêmes objets). En utilisant par référence le compilateur ne peut pas supposer que toujours. Exemple Simple:
```
foo * f;

void bar(foo g) {
    g.i = 10;
    f->i = 2;
    g.i += 5;
}
```
le compilateur peut optimiser en
```
g.i = 15;
f->i = 2;
```
puisqu'il sait que f et g ne partage pas le même emplacement. si g est une référence (foo &), le compilateur ne pouvais pas supposer que. depuis g.j'ai pu alors être lissés par f->je et avoir une valeur de 7. ainsi, le compilateur devra re-chercher la nouvelle valeur de g.j'ai de la mémoire.

Pour plus de pratique des règles, ici, c'est un bon ensemble de règles trouvé dans Constructeurs De Déplacement article (très recommandé la lecture).
- Si la fonction a l'intention de changer l'argument comme un effet secondaire, de le prendre par la non-const de référence.
- Si la fonction ne modifie pas ses arguments, et l'argument est de type primitif, de le prendre par la valeur.
- Sinon de le prendre par la const de référence, sauf dans les cas suivants
  - Si la fonction serait alors nécessaire de faire une copie de la const de référence, de toute façon, le prendre par la valeur.
"Primitive" ci-dessus désigne essentiellement de petites types de données qui sont quelques octets de long et ne sont pas polymorphes (itérateurs, la fonction des objets, etc...) ou coûteux à copier. Dans ce papier, il y a une autre règle. L'idée est que, parfois, on veut faire une copie (dans le cas où l'argument ne peut pas être modifié), et parfois on ne veut pas (dans le cas où l'on veut utiliser l'argument lui-même dans la fonction si l'argument est un temporaire de toute façon, par exemple). Le document explique en détail comment cela peut être fait. En C++1x, cette technique peut être utilisée en mode natif avec support de la langue. Jusqu'alors, je voudrais aller avec les règles ci-dessus.

Exemples: Pour faire une chaîne de caractères en majuscules et à retourner à la version en majuscules, on doit toujours passer par valeur: On doit en prendre une copie de toute façon (on ne pouvait pas changer la const référence directement) - afin de mieux rendre aussi transparente que possible à l'appelant et de faire cette copie précoce de sorte que l'appelant peut optimiser autant que possible, comme détaillé dans le document en:
```
my::string uppercase(my::string s) { /* change s and return it */ }
```
Toutefois, si vous n'avez pas besoin de changer le paramètre de toute façon, le prendre par la référence à la const:
```
bool all_uppercase(my::string const& s) { 
    /* check to see whether any character is uppercase */
}
```
Toutefois, si vous le but de ce paramètre est d'écrire quelque chose dans l'argument, puis la passer par des non-const de référence
```
bool try_parse(T text, my::string &out) {
    /* try to parse, write result into out */
}
```
- j'ai trouvé vos règles de bon, mais im pas sûr de la première partie où u parle pas de le transmettre comme ref permettrait d'accélérer. ouais, bien sûr, mais pas de transmission de quelque chose comme une ref juste cus de optimaztion ne fait pas de sens. si vous voulez changer la pile de l'objet que vous êtes de passage en, le faire par la réf. si vous n'avez pas, passer par valeur. si vous ne voulez pas le changer, de le passer comme const-réf. l'optimisation qui vient avec le passage par valeur, ne devrait pas d'importance puisque vous obtenir d'autres choses lors du passage en réf. je ne comprends pas le "veulent la vitesse?" sice si vous où va l'exécution de ces op, que vous devez passer par la valeur de toute façon..
- Johannes: je aimé cet article, lorsque je l'ai lu, mais j'ai été déçu quand je l'ai essayé. Ce code a échoué sur les deux GCC et MSVC. Ai-je raté quelque chose, ou qu'il ne fonctionne pas dans la pratique?
- Je ne pense pas que je suis d'accord que si vous voulez faire une copie de toute façon, vous auriez du passer par valeur (au lieu de const ref), puis de le déplacer. Regardons cela de cette façon, ce qui est plus efficace, une copie et déplacement (vous pouvez même avoir 2 copies si vous passer vers l'avant), ou tout simplement une copie? Oui il existe quelques cas particuliers de chaque côté, mais si vos données ne peuvent pas être déplacés de toute façon (ex: un POD avec des tonnes de nombres entiers), pas besoin de copies supplémentaires.
- Mehrdad, vous ne savez pas ce que vous attendiez, mais le code fonctionne comme prévu
- Je voudrais examiner la nécessité de copier simplement de convaincre le compilateur que les types ne se chevauchent pas une carence dans la langue. Je préfère utiliser du CCG __restrict__ (qui peut aussi fonctionner sur des références) que ne le font excessive des copies. Dommage que la norme C++ n'a pas adopté le C99 est restrict mot-clé.
InformationsquelleAutor Johannes Schaub - litb
12

Dépend du type. Vous ajoutez la petite surcharge d'avoir à faire référence et de déréférencement. Pour les types avec une taille égale ou plus petite que les pointeurs qui sont à l'aide de la copie par défaut ctor, il serait probablement plus rapide de passer par valeur.
- Pour les non-autochtones, vous pouvez (en fonction de la manière dont le compilateur optimise le code) à obtenir une augmentation de la performance à l'aide de constantes références au lieu de simplement les références.
InformationsquelleAutor Lou Franco
8

Comme il a été souligné, cela dépend du type. Pour les types de données intégrés, il est préférable de passer par valeur. Même de très petites structures, comme une paire d'entiers peuvent donner de meilleurs résultats en passant par valeur.

Voici un exemple, supposons que vous disposez d'une valeur de nombre entier et que vous souhaitez passer à une autre routine. Si cette valeur a été optimisé pour être stocké dans un registre, si vous souhaitez passer la référence, elle doit d'abord être stockées dans la mémoire et ensuite un pointeur vers la mémoire placés sur la pile pour effectuer l'appel. S'il était passé par valeur, tout ce qui est nécessaire est le registre poussé sur la pile. (Les détails sont un peu plus compliquées que ce que donne les différents systèmes d'appel et les Processeurs).

Si vous faites modèle de programmation, vous êtes souvent obligés de toujours passer par const ref puisque vous ne connaissez pas le type qui est passée. En passant des pénalités pour le passage de quelque chose de mauvais, en valeur, sont bien pires que les pénalités en cas de passage d'un type intégré par const réf.
- Remarque sur la terminologie: une structure contenant un million ints est encore un "type POD". Peut-être que tu veux dire "pour les types intégrés, il est préférable de passer par valeur".
- Terminologie corrigé.
- Bonne explication de l'arrière-scène mécanisme de! +1
InformationsquelleAutor Torlack
5

Sonne comme vous avez obtenu votre réponse. Passage par valeur est cher, mais vous donne une copie de travailler avec si vous en avez besoin.
- Je ne suis pas sûr de savoir pourquoi cela a été voté à la baisse? Il fait sens pour moi. Si vous allez avoir besoin de la valeur actuellement stockés, puis le passage par valeur. Si non, passer à la référence.
- Il est totalement dépendante du type. Faire un POD (plain old data), de type par référence peuvent en fait réduire les performances par causer plus de l'accès à la mémoire.
- Évidemment, en passant int par référence n'est pas sauver quoi que ce soit! Je pense que la question implique des choses qui sont plus grandes que d'un pointeur.
- Il n'est pas évident, j'ai vu beaucoup de code par des gens qui ne pas vraiment comprendre comment fonctionne un ordinateur en passant les choses simples par const réf parce qu'ils ont dit c'est la meilleure chose à faire.
InformationsquelleAutor GeekyMonkey
5

C'est ce que j'ai l'habitude de travailler par lors de la conception de l'interface d'un non-modèle de fonction:
1. Passage par valeur si la fonction ne souhaitez pas modifier le paramètre et la
  la valeur n'est pas cher pour la copie (int, double, float, char, boolean, etc... Notez que std::string, std::vector, et le reste des conteneurs de la bibliothèque standard ne le sont PAS)
2. Passer par const pointeur si la valeur est cher pour la copie et la fonction ne
  voulez pas modifier la valeur pointée et la valeur NULL est une valeur que la fonction de poignées.
3. Passer par des non-const pointeur si la valeur est cher pour de la copie et de la fonction
  veut modifier la valeur pointée et la valeur NULL est une valeur que la fonction de poignées.
4. Passer par référence const lorsque la valeur est cher pour la copie et la fonction ne voulez pas modifier la valeur visée et NUL ne serait pas une valeur valide si un pointeur est utilisé à la place.
5. Passer par des non-const de référence lorsque la valeur est cher pour de la copie et de la fonction veut modifier la valeur visée et NUL ne serait pas une valeur valide si un pointeur est utilisé à la place.
InformationsquelleAutor Martin G
4

Comme une règle de passage par référence const, c'est mieux.
Mais si vous avez besoin de modifier vous argument de fonction localement, il est mieux d'utiliser le passage par valeur.
Pour certains types de base de la performance en général les mêmes pour le passage par valeur et par référence. Fait référence à l'interne représentée par un pointeur, c'est pourquoi vous pouvez vous attendre par exemple que pour le pointeur à la fois de passage sont les mêmes en termes de performance, ou même le passage par valeur peut être plus rapide en raison de inutile de déréférencement.
- Si vous avez besoin de modifier le destinataire de l'appel de la copie du paramètre, vous pouvez faire une copie dans le code plutôt que de passer par valeur. L'OMI en général, vous ne devriez pas choisir l'API basée sur la mise en oeuvre détails, tels que: l'appelant du code source est la même, mais son code objet ne l'est pas.
- Si vous passez par la valeur de la copie est créée. Et de l'OMI n'est pas question de la façon dont vous créez une copie: via argument passage par valeur ou localement - ce en ce qui concerne le C++. Mais à partir de la conception de point de vue je suis d'accord avec vous. Mais je décrire des fonctionnalités C++ ici seulement et ne touchez pas à la conception.
InformationsquelleAutor sergtk
1

En règle générale, la valeur de non-types de classe et const référence pour les classes.
Si une classe est vraiment petit, il est probablement préférable de passer par valeur, mais la différence est minime. Ce que vous voulez vraiment éviter, c'est le passage d'un nombre gigantesque de classe par valeur et de l'avoir tous les dupliqué - cela fera une énorme différence si vous êtes de passage, disons, un std::vector avec peu d'éléments.
- Ma compréhension est que std::vector fait alloue ses articles sur le tas et le vecteur de l'objet lui-même ne pousse jamais. Oh, attendez. Si l'opération entraîne une copie du vecteur d'être fait, si, elle en fait aller et de dupliquer tous les éléments. Ce serait mauvais.
- Oui, c'est ce que je pensais. sizeof(std::vector<int>) est constant, mais le passage par valeur sera toujours copier le contenu en l'absence de toute compilateur intelligence.
InformationsquelleAutor Peter
1

Passage par valeur pour les petits types.

Passer par const références pour les grands types (la définition de la taille peut varier entre les machines) MAIS, en C++11, le passage par valeur si vous allez consommer les données, puisque vous pouvez exploiter la sémantique de déplacement. Par exemple:
```
class Person {
 public:
  Person(std::string name) : name_(std::move(name)) {}
 private:
  std::string name_;
};
```
Maintenant l'appel de code:
```
Person p(std::string("Albert"));
```
Et un seul objet sera créé et déplacé directement dans les name_ dans la classe Person. Si vous passez par const référence, une copie devra être fait pour le mettre dans name_.

InformationsquelleAutor Germán Diago
-5

Simple différence :- Dans la fonction, nous avons d'entrée et de sortie paramètre , donc si votre passage d'entrée et de sortie paramètre est même alors utiliser l'appel par référence à l'autre, s'en entrée et en sortie paramètre est différente de mieux utiliser l'appel par valeur .

exemple void amount(int account , int deposit , int total )

paramètre d'entrée : compte de dépôt
sortie paramteter: total

d'entrée et de sortie est différent d'appel par vaule
1. void amount(int total , int deposit )
d'entrée total de la caution
sortie totale

InformationsquelleAutor Dhirendra Sengar

Vous devez vous connecter pour publier un commentaire.

Souhaitez vitesse? Le passage par valeur.