自分配签入分配运算符-yiteyi-C++库

在C++中，赋值运算符应重载自赋值检查。

null

例如，考虑下面的类大堆重载赋值运算符函数，无需自我赋值检查。

                     // A sample class                   
                     class                               Array {                   
                                         private                               :                   
                                         int                               *ptr;                   
                                         int                               size;                   
                                         public                               :                   
                                         Array& operator = (                               const                               Array &rhs);                   
                                         // constructors and other functions of class........                   
                     };                   
                             
                     // Overloaded assignment operator for class Array (without self                   
                     // assignment check)                   
                     Array& Array::operator = (                               const                               Array &rhs)                   
                     {                   
                                         // Deallocate old memory                   
                                         delete                               [] ptr;                   
                             
                                         // allocate new space                   
                                         ptr =                               new                               int                               [rhs.size];                   
                             
                                         // copy values                   
                                         size = rhs.size;                   
                                         for                               (                               int                               i = 0; i < size; i++)                   
                                         ptr[i] = rhs.ptr[i];                   
                             
                                         return                               *                               this                               ;                   
                     }                   

如果我们有目标说 a1 数组类型，如果我们有一条像 a1=a1 在某些地方，程序会导致不可预测的行为，因为上面的代码中没有自我分配检查。为了避免上述问题，重载赋值运算符时必须进行自赋值检查。例如，下面的代码执行自我分配检查。

                     // Overloaded assignment operator for class Array (with self                   
                     // assignment check)                   
                     Array& Array::operator = (                               const                               Array &rhs)                   
                     {                   
                                         /* SELF ASSIGNMENT CHECK */                   
                                         if                               (                               this                               != &rhs)                   
                                         {                   
                                         // Deallocate old memory                   
                                         delete                               [] ptr;                   
                             
                                         // allocate new space                   
                                         ptr =                               new                               int                               [rhs.size];                   
                             
                                         // copy values                   
                                         size = rhs.size;                   
                                         for                               (                               int                               i = 0; i < size; i++)                   
                                         ptr[i] = rhs.ptr[i];                   
                                         }                   
                             
                                         return                               *                               this                               ;                   
                     }                   

参考资料： http://www.cs.caltech.edu/courses/cs11/material/cpp/donnie/cpp-ops.html

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

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

THE END

技术文章