Ce sont des copier élision et la valeur de retour d'optimisation?

Norme de référence

Pour les moins techniques view & introduction - passez à cette réponse.

Communes pour les cas où la copie élision se produit - passez à cette réponse.

Copie élision est défini dans la norme:

De 12,8 la Copie et le déplacement des objets de la classe [classe.copie]

comme

31) Lorsque certains critères sont respectés, une mise en œuvre est permis d'omettre de le copier/déplacer construction d'une classe
objet, même si le copier/déplacer constructeur et/ou le destructeur de l'objet ont des effets secondaires. Dans de tels cas,
la mise en œuvre traite de la source et de la cible de l'omis de copier/déplacer des fonctionnement que simplement deux
manières de se référer au même objet, et la destruction de cet objet se produit au plus tard à la fois
lorsque les deux objets ont été détruits sans l'optimisation.¹²³ Cette élision de copier/déplacer
opérations, appelées copie élision, est autorisé dans les circonstances suivantes (qui peuvent être combinées pour
éliminer plusieurs copies):

— dans une instruction return dans une fonction avec une classe de type de retour, lorsque l'expression est le nom d'un
non-volatile automatique d'objets (autre qu'une fonction ou catch-clause de paramètre) avec le même cvunqualified
type que le type de retour de fonction, le copier/déplacer opération peut être omis, par la construction de
l'automatique des objets directement dans la valeur renvoyée de la fonction

— dans un jet d'expression, lorsque l'opérande est le nom d'un non-volatile automatique d'objets (autres que les
fonction ou catch-clause de paramètre) dont la portée ne s'étend pas au-delà de la fin de l'intime
en joignant essayez-bloc (si il y en a un), le copier/déplacer le fonctionnement de l'opérande à l'exception
objet (15.1) peut être omis par la construction automatique de l'objet directement dans l'objet de l'exception

— lorsqu'un temporaire de la classe de l'objet qui n'a pas été lié à une référence (12.2) serait copié/déplacé
pour un objet de classe avec le même cv-non qualifiés de type, le copier/déplacer opération peut être omis par
la construction de l'objet temporaire directement dans la cible de l'omis de copier/déplacer des

— lorsque l'exception-la déclaration d'un gestionnaire d'exception (article 15) déclare un objet de même type
(sauf pour le cv-qualification) que l'objet de l'exception (15.1), le copier/déplacer opération peut être omis
par le traitement de l'exception-déclaration comme un alias pour l'objet de l'exception si le sens du programme
sera inchangé, sauf pour l'exécution de constructeurs et destructeurs pour l'objet déclaré par
l'exception-déclaration.

_{123) Parce qu'un objet est détruit au lieu de deux, et un copier/déplacer constructeur n'est pas exécuté, il est toujours une
objet détruit pour chacun construit.}

L'exemple donné est:

class Thing {
public:
  Thing();
  ~Thing();
  Thing(const Thing&);
};
Thing f() {
  Thing t;
  return t;
}
Thing t2 = f();

et a expliqué:

Ici les critères d'élision peuvent être combinés pour éliminer les deux appels au constructeur de copie de la classe Thing:
la copie du ou des locaux automatique des objets t dans l'objet temporaire pour la valeur de retour de la fonction f()
et la copie de l'objet temporaire en objet t2. Effectivement, la construction de l'objet local t
peut être considéré comme directement de l'initialisation de l'objet global t2, et que l'objet de la destruction se fera au programme
à la sortie. L'ajout d'un constructeur de déplacement de Chose a le même effet, mais c'est le mouvement de construction de l'
objet temporaire pour t2 qui est élidée.

OriginalL'auteur Luchian Grigore

Copie élision est un compilateur technique d'optimisation qui élimine les copier/déplacer des objets.

Dans les circonstances suivantes, un compilateur est permis d'omettre de copier/déplacer des opérations et donc de ne pas appeler le constructeur associé:

1. NRVO (Nommé en Valeur de Retour d'Optimisation): Si une fonction retourne un type de classe par valeur et l'instruction de retour de l'expression est le nom d'un non-volatile objet automatique de la durée de stockage (ce qui n'est pas un paramètre de la fonction), puis le copier/déplacer qui serait effectuée par un non-optimisation du compilateur peuvent être omis. Si oui, la valeur retournée est construit directement dans le stockage à qui de retour de la fonction de valeur serait autrement être déplacés ou copiés.
2. RVO (Valeur de Retour d'Optimisation): Si la fonction renvoie un nom temporaire des objets qui devrait être déplacés ou copiés dans la destination par un naïf compilateur, le copier ou déplacer peut être omise que par 1.

#include <iostream>  
using namespace std;
class ABC  
{  
public:   
const char *a;  
ABC()  
{ cout<<"Constructor"<<endl; }  
ABC(const char *ptr)  
{ cout<<"Constructor"<<endl; }  
ABC(ABC  &obj)  
{ cout<<"copy constructor"<<endl;}  
ABC(ABC&& obj)  
{ cout<<"Move constructor"<<endl; }  
~ABC()  
{ cout<<"Destructor"<<endl; }  
};
ABC fun123()  
{ ABC obj; return obj; }  
ABC xyz123()  
{  return ABC(); }  
int main()  
{  
ABC abc;  
ABC obj1(fun123());//NRVO  
ABC obj2(xyz123());//NRVO  
ABC xyz = "Stack Overflow";//RVO  
return 0;  
}
**Output without -fno-elide-constructors**  
root@ajay-PC:/home/ajay/c++# ./a.out   
Constructor    
Constructor  
Constructor  
Constructor  
Destructor  
Destructor  
Destructor  
Destructor  
**Output with -fno-elide-constructors**  
root@ajay-PC:/home/ajay/c++# g++ -std=c++11 copy_elision.cpp -fno-elide-constructors    
root@ajay-PC:/home/ajay/c++# ./a.out   
Constructor  
Constructor  
Move constructor  
Destructor  
Move constructor  
Destructor  
Constructor  
Move constructor  
Destructor  
Move constructor  
Destructor  
Constructor  
Move constructor  
Destructor  
Destructor  
Destructor  
Destructor  
Destructor  

Même lorsque la copie élision prend de la place et la copier/déplacer-constructeur n'est pas appelé, il doit être présent et accessible (comme si une optimisation est arrivé à tous), sinon le programme est mal formé.

Vous devriez permettre une telle copie élision seulement dans des endroits où il n'affecte pas le comportement visible de votre logiciel. Copie élision est la seule forme de l'optimisation autorisée à faire (c'est à dire éluder) observables effets secondaires. Exemple:

#include <iostream>     
int n = 0;    
class ABC     
{  public:  
ABC(int) {}    
ABC(const ABC& a) { ++n; } //the copy constructor has a visible side effect    
};                     //it modifies an object with static storage duration    
int main()   
{  
ABC c1(21); //direct-initialization, calls C::C(42)  
ABC c2 = ABC(21); //copy-initialization, calls C::C( C(42) )  
std::cout << n << std::endl; //prints 0 if the copy was elided, 1 otherwise
return 0;  
}
Output without -fno-elide-constructors  
root@ajay-PC:/home/ayadav# g++ -std=c++11 copy_elision.cpp  
root@ajay-PC:/home/ayadav# ./a.out   
0
Output with -fno-elide-constructors  
root@ajay-PC:/home/ayadav# g++ -std=c++11 copy_elision.cpp -fno-elide-constructors  
root@ajay-PC:/home/ayadav# ./a.out   
1

GCC fournit la -fno-elide-constructors option pour désactiver la copie élision.
Si vous voulez éviter de copie possible élision, l'utilisation -fno-elide-constructors.

Maintenant presque tous les compilateurs fournir une copie élision lorsque l'optimisation est activée (et si aucune autre option est de le désactiver).

Conclusion

Avec chaque copie élision, une construction et un correspondant de la destruction de la copie sont omis, économisant ainsi du temps CPU, et qu'un objet n'est pas créé, économisant ainsi de l'espace sur le frame de pile.

OriginalL'auteur Ajay yadav