Différence constructeur de copie et la surcharge d'opérateur d'affectation

Regardez un exemple:

#include<iostream>
using namespace std;
class Demo
{
public:
    //构造函数
    Demo(int num)
    {
        m_num = num;
        printf("constructor\n");
    }
    //拷贝构造函数
    Demo(const Demo & demo)
    {
        m_num = demo.m_num;
        printf("copy constructor\n");
    }

	//赋值运算符重载
    Demo& operator=(const Demo& demo)
    {
        m_num = demo.m_num;
        printf("operator=\n");
        return *this;
    }

    //析构函数
    ~Demo()
    {
        cout<<"destructor\n";
    }
private:
    int m_num;
};
int main()
{
    Demo A(100); // 产生一个实例，调用一次构造函数
    Demo B=A;    // 调用拷贝构造函数，产生一个实例

    Demo C(20);  // 产生一个实例，调用一次构造函数
    C = A;	     // 调用赋值运算符重载
    return 0;
}

Résultats Run: trois fois configuré destructor

  

  Par défaut (l'utilisateur n'est pas défini, mais également supprimé non représenté), le compilateur génère implicitement automatiquement un constructeur de copie et d'affectation, mais l'utilisateur peut supprimer la nouvelle norme de ne pas spécifier généré constructeur de copie et opérateur d'affectation, ces objets ne peuvent pas être passés par valeur, ne peut pas être effectuée opération d'affectation

possibilité d'appel:
 1) appeler le constructeur de copie: Lorsque vous créez un nouvel objet (y compris les objets temporaires et créer des objets passent des paramètres générés)

 2) opérateur d'affectation d'appel: l'objet a été généré