1

这是我发现的实现“三法则”的示例：

class Array { 
    public: 
        int size; 
        int* vals;
        Array() : size(0), vals(NULL){}
        Array( int s, int* v );
        Array(const Array&); // 1
        Array& operator=(const Array&); // 2
        ~Array(); // 3
}; 

Array::~Array() { 
   delete []vals; 
   vals = NULL; 
} 

Array::Array( int s, int* v ){
    size = s; 
    vals = new int[size]; 
    std::copy( v, v + size, vals ); 
} 

Array::Array(const Array& rhs):
    size(rhs.size),
        vals((rhs.size) ? new int[size] : NULL)
{
    if(size)
        std::copy(rhs.vals, rhs.vals + rhs.size, vals);
}

Array& Array::operator=(const Array& rhs){
//  if(this == &rhs) // no need
//      return *this;
    int* a = (rhs.size)? new int[rhs.size] : NULL; // this is why we don't need the above check: if this line throws then vals is untouched. if this is ok (local variable) then continue (next won't throw).
    std::copy(rhs.vals, rhs.vals + rhs.size, a); // copying to a even (self assignment won't harm)
    delete[] vals;
    vals = a;
    size = rhs.size;

    return *this;
}

正如您在上面看到的，复制赋值运算符中的检查被删除，因为创建局部变量然后删除成员指针并将其分配给局部变量。但是，如果我写，我最重要的是：

int main() {
   int vals[ 4 ] = { 11, 22, 33, 44 };  
   Array a1( 4, vals ); 

   a1 = a1; // here I assigned a1 to itself

    return 0;
}

我分配a1给自己这是否意味着a1'vals被删除，然后a在复制分配运算符中分配了本地？这是正确的方法吗？我的代码有一些陷阱吗？

  • 任何提示，建议都非常感谢。
4

1 回答 1

8

复制赋值运算符将起作用，从某种意义上说，自赋值将具有预期的行为：数组的值内容将保持不变。

不做测试你失去的是，如果你已经持有一个数组，你将分配一个你不需要的数组，执行一个你不需要做的副本，然后销毁你本可以保留的东西。

这是否对性能很重要……这在很大程度上取决于依赖于使用的因素。毕竟，这只有在您执行自复制时才会出现问题。你多久这样做一次？如果你真的不经常（或永远）不这样做，那么测试只是你不需要的条件分支。

同时，考虑 的定义vector。当迭代器/指针/引用vector失效时，它有非常具体的情况。而抄袭vector不是其中之一。因此，如果对象存储的位置是数组类型接口的一部分（它的方式vector），那么进行自复制对您的接口有更广泛的影响。

于 2018-12-10T22:09:11.080 回答