C++ - Quelle est la différence entre utiliser et ne pas utiliser const dans Copy Constructor?

Question

Ce code contient une erreur.

[Error] no matching function for call to Complex::Complex(Complex) 

Mais lorsque ce code écrire que Complex(const Complex & newComplex),

utiliser juste const, ce code fonctionne très bien.

pourquoi? Je ne sais pas pourquoi. S'il vous plaît dites-moi la réponse.

#include <iostream> 
using namespace std; 

class Complex { 
    double re, im; 
public: 
    Complex(double _re = 0, double _im = 0): re(_re), im(_im) {} 
    Complex(Complex & newComplex) { 
     re = newComplex.re; 
     im = newComplex.im; 
    } 
    ~Complex() {} 
    Complex operator + (Complex & inputComplex) { 
     Complex tempComplex; 
     tempComplex.re = re + inputComplex.re; 
     tempComplex.im = im + inputComplex.im; 
    return tempComplex; 
    } 
}; 

int main() 
{ 
    Complex c1(1, 0), c2(2, 1); 
    Complex c3(c1 + c2); 
} 

Answer 1

références Const se comportent différemment des références normales, quand ils sont passés un rvalue (essentiellement un objet temporaire).

Lorsque vous liez une référence const à un objet temporaire, elle prolonge la durée de vie du temporaire et l'amène à la portée de la référence. Les références non-const ne peuvent pas faire cela, donc votre constructeur n'acceptera pas c1 + c2 (dont le type de retour est un objet temporaire) comme argument.

Answer 2

Un paramètre de type T & est une référence lvalue. Une référence lvalue doit référencer une lvalue (et un objet temporaire n'est pas une lvalue).

Un objet temporaire (comme celui obtenu à partir de c1+c2) n'est pas une lvalue, donc une référence à T (non-const) ne peut pas s'y lier. Bien qu'il s'agisse toujours d'une référence à une lvalue, une référence à const T (c'est-à-dire, T const & ou const T &) est autorisée à se lier à un objet temporaire.

Dans certaines circonstances (mais probablement pas dans ce cas), vous pouvez envisager d'utiliser le constructeur de déplacement qui utilise une référence rvalue à la place. Cela permet au nouvel objet de "voler" le contenu de l'objet temporaire au lieu de le copier. C'est particulièrement utile dans le cas de quelque chose comme une chaîne ou un vecteur qui possède potentiellement une grande quantité de mémoire allouée dynamiquement qui appartient à l'objet, mais qui peut être déplacée d'un objet à l'autre simplement en copiant le pointeur plutôt que toutes les données.