我们应该在C++中编写自己的赋值操作符？-yiteyi-C++库

答案与复制构造函数相同。如果一个类不包含指针，那么就不需要编写赋值运算符和复制构造函数。编译器为每个类创建一个默认的复制构造函数和赋值运算符。当我们有指针或任何运行时资源分配（如文件句柄、网络连接）时，编译器创建的复制构造函数和赋值运算符可能不够。。例如，考虑下面的程序。

null

                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     // A class without user defined assignment operator                   
                     class                               Test                   
                     {                   
                                         int                               *ptr;                   
                     public                               :                   
                                         Test (                               int                               i = 0)      { ptr =                               new                               int                               (i); }                   
                                         void                               setValue (                               int                               i) { *ptr = i; }                   
                                         void                               print()          { cout << *ptr << endl; }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         Test t1(5);                   
                                         Test t2;                   
                                         t2 = t1;                   
                                         t1.setValue(10);                   
                                         t2.print();                   
                                         return                               0;                   
                     }                   

上述程序的输出为“10”。如果我们看一下main（），我们使用setValue（）函数修改了’t1’，但这些变化也反映在对象’t2’中。这种类型的意外更改会导致问题。由于上述程序中没有用户定义的赋值运算符，编译器创建了一个默认赋值运算符，它将右侧的“ptr”复制到左侧。所以两个ptr开始指向同一个位置。

我们可以用两种方法处理上述问题。

1) 不允许将一个对象指定给另一个对象。我们可以创建自己的虚拟赋值运算符并将其私有化。

2) 编写自己的赋值运算符进行深度复制。

复制构造函数也是如此。

下面是为上述类重载赋值运算符的示例。

                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               Test                   
                     {                   
                                         int                               *ptr;                   
                     public                               :                   
                                         Test (                               int                               i = 0)      { ptr =                               new                               int                               (i); }                   
                                         void                               setValue (                               int                               i) { *ptr = i; }                   
                                         void                               print()          { cout << *ptr << endl; }                   
                                         Test & operator = (                               const                               Test &t);                   
                     };                   
                             
                     Test & Test::operator = (                               const                               Test &t)                   
                     {                   
                                         // Check for self assignment                   
                                         if                               (                               this                               != &t)                   
                                         *ptr = *(t.ptr);                   
                             
                                         return                               *                               this                               ;                   
                     }                   
                             
                     int                               main()                   
                     {                   
                                         Test t1(5);                   
                                         Test t2;                   
                                         t2 = t1;                   
                                         t1.setValue(10);                   
                                         t2.print();                   
                                         return                               0;                   
                     }                   

输出

我们还应该在上面的类中添加一个复制构造函数，这样“Test t3=t4也不要造成任何问题。

注意赋值运算符中的if条件。重载赋值运算符时，必须检查自赋值。否则，将对象指定给自身可能会导致意外结果（请参见这 ).对于上述“Test”类，不需要进行自分配检查，因为“ptr”始终指向一个整数，我们可能会重用相同的内存。但一般来说，建议进行自我分配检查。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END