检查复制构造函数中的“自赋值”？

Question

今天在大学里，一位教授推荐我在复制构造函数中检查(this != &copy)，类似于重载operator= 时应该如何检查。但是我对此提出了质疑，因为我想不出在构造对象时this 会等于参数的任何情况。

他承认我的观点很好。所以，我的问题是，执行此检查是否有意义，或者这不可能搞砸？

编辑：我想我是对的，但我会暂时把它打开。也许有人想出了一些疯狂的神秘 C++ 魔法。

Edit2：Test a(a) 在 MinGW 上编译，但不是 MSVS10。 Test a = a 两者都编译，所以我认为 gcc 的行为会有些相似。不幸的是，VS 确实不显示带有“未初始化的变量使用”的调试消息。但是，它确实为int i = i 正确显示了此消息。这真的可以被认为是一个 c++ 语言缺陷吗？

class Test
{
   Test(const Test &copy)
   {
      if (this != &copy) // <-- this line: yay or nay?
      {
      }
   }
   Test &operator=(const Test &rhd)
   {
      if (this != &rhd) // <-- in this case, it makes sense
      {
      }
   }
};

Answer 1

就个人而言，我认为你的教授错了，原因如下。

当然，代码会编译。当然，代码被破坏了。但这就是你的教授的推理，然后他得出结论：“哦，我们应该看看我们是否在自我分配，如果是，就回来。”

但这很糟糕，因为同样的原因，拥有一个不做任何事情的全局包罗万象的catch(...) 是邪恶的。您正在防止立即出现问题，但问题仍然存在。代码无效。您不应该使用指向 self 的指针调用构造函数。解决方案不是忽略问题并继续前进。解决方案是修复代码。 最好的 可能发生的事情是您的代码会立即崩溃。 最糟糕的事情是代码将在一段时间内继续处于无效状态，然后稍后崩溃（当调用堆栈对您没有好处时），或者生成无效输出。

不，你的教授错了。在不检查自我分配的情况下完成分配。在代码审查中找到缺陷，或者让代码崩溃并在调试会话中找到它。但不要只是继续，好像什么都没发生过。

Answer 2

这是有效的 C++ 并调用复制构造函数：

Test a = a;

但这没有任何意义，因为a是在初始化之前使用的。

Answer 3

如果你想偏执，那么：

class Test
{
   Test(const Test &copy)
   {
       assert(this != &copy);
       // ...
   }
};

如果this == &copy，你永远不想继续。我从来没有为这张支票烦恼过。在我使用的代码中似乎并不经常发生该错误。但是，如果您的经验不同，那么断言可能是值得的。

Answer 4

您的导师可能正试图避免这种情况 -

#include <iostream>

class foo
{
    public:
    foo( const foo& temp )
    {
        if( this != &temp )
        std::cout << "Copy constructor \n";
    }
};

int main()
{
    foo obj(obj);  // This is any how meaning less because to construct
                   // "obj", the statement is passing "obj" itself as the argument

}

由于名称（即obj）在时间声明时可见，因此代码编译并有效。

Answer 5

您的教师可能正在考虑在 copy assignment 运算符中检查自我分配。

在 Sutter 和 Alexandrescu 的“C++ 编码标准”以及 Scott Meyer 早期的“Effective C++”中都建议检查赋值运算符中的自赋值。

Answer 6

在正常情况下，这里似乎没有必要。但请考虑以下情况：

class A{ 
   char *name ; 
public:
   A & operator=(const A & rhs);
};

A & A::operator=(const A &rhs){
   name = (char *) malloc(strlen(rhs.name)+1);
   if(name) 
      strcpy(name,rhs.name);
   return *this;
}

显然，在我们进行自赋值的情况下，上面的代码存在问题。在我们可以复制内容之前，指向原始数据的指针将丢失，因为它们都引用同一个指针。这就是为什么我们需要检查自我分配。功能应该是这样的

A & A::operator=(const A &rhs){
     if(this != &rhs){
       name = (char *) malloc(strlen(rhs.name)+1);
       if(name) 
          strcpy(name,rhs.name);
     } 
   return *this;
}

Answer 7

在编写赋值运算符和复制构造函数时，总是这样做：

struct MyClass
{
    MyClass(const MyClass& x)
    {
        // Implement copy constructor. Don't check for
        // self assignment, since &x is never equal to *this.
    }

    void swap(MyClass& x) throw()
    {
        // Implement lightweight swap. Swap pointers, not contents.
    }

    MyClass& operator=(MyClass x)
    {
        x.swap(*this); return *this;
    }
};

将x 按值传递给赋值运算符时，会生成一个副本。然后将其与*this 交换，并在返回时调用x 的析构函数，并使用旧值*this。简单、优雅、异常安全、无代码重复、无需自分配测试。

如果您还不了解异常，您可能希望在学习异常安全时记住这个习语（暂时忽略 swap 的 throw() 说明符）。

Answer 8

我同意自检在复制构造函数中没有任何意义，因为尚未创建对象，但您的教授为了避免任何进一步的问题而添加检查是正确的。我尝试了带/不带自检，当没有自检时得到了意外的结果，如果存在自检，则出现运行时错误。

class Test
{    
    **public:**
    Test(const Test& obj )
    {
       size = obj.size;
       a = new int[size];   
    }

    ~Test()
    {....}

    void display()
    {
        cout<<"Constructor is valid"<<endl;
    }
    **private:**

 }

创建复制构造函数并调用成员函数时我没有

 Test t2(t2);
 t2.display(); 

输出：
内部默认构造函数
内部参数化构造函数
内部复制构造函数
构造函数有效

这在语法上可能是正确的，但看起来不正确。 通过自我检查，我得到了运行时错误，指出代码中的错误，以避免这种情况。

    Test(const Test& obj )
    {
        if(this != &obj )
        {
            size = obj.size;
            a = new int[size];
        }
    }

运行时错误：
`/home/bot/1eb372c9a09bb3f6c19a27e8de801811' 中的错误：munmap_chunk()：无效指针：0x0000000000400dc0

Answer 9

一般来说，operator= 和拷贝构造函数调用拷贝函数，所以有可能发生自赋值。 所以，

Test a;
a = a;

例如，

const Test& copy(const Test& that) {
    if (this == &that) {
        return *this
    }
    //otherwise construct new object and copy over
}
Test(const &that) {
    copy(that);
}

Test& operator=(const Test& that) {
    if (this != &that) { //not checking self 
        this->~Test();
    }
    copy(that);
 }

上面，当a = a被执行时，操作符重载被调用，它调用复制函数，然后检测自赋值。