2

最近我一直在研究 Meyers 的 Effective C++ 第三版。对于我目前正在从事的项目，我必须创建一个我明确希望禁止使用编译器生成的函数的类。我使用上述书中的第 6 项作为参考实现了代码，唯一的主要区别在于我的类是模板化的。它的代码如下

template <class T>
class Uncopyable
{
protected:
    Uncopyable<T>(){}
    virtual ~Uncopyable<T>(){}
private:
    Uncopyable<T>(const Uncopyable<T>&);
    Uncopyable<T>& operator=(const Uncopyable<T>&);
};

我的测试功能。

class Test : private Uncopyable<Test>
{
public:
    Test(){}
    ~Test(){}
    inline void test()
    {
        std::cout << "blah" << std::endl;
    }
private:
protected:
};

当这样使用时，代码完全按预期工作

int main(int argc, char* argv[])
{
    Test t1, t2;

    // Works as expected, doesnt allow copying of object
    t2 = t1;
    // and this works fine, no copying
    Test t3 = t2;

    // finally, works correctly no copying is allowed
    Test t4(t1);

    return 0;
}

然而，当像这样使用时，代码编译得很好并且可以进行复制，但它不应该能够吗？

int main(int argc, char* argv[])
{
    Test* t1 = new Test(), *t2;
    t1->test();
    // Works when it shouldnt work?
    t2 = t1;
    t2->test();

    // same with this
    Test* t3 = t2;
    t3->test();

    // and this
    Test* t4(t1);
    t4->test();

    delete t1;

    return 0;
}

我在没有模板类的情况下尝试过，结果是一样的，所以我认为这不是问题。

那么，为什么允许这种情况发生？我的代码中是否有错误，或者我只是理解错误的概念？谢谢。

4

4 回答 4

4

您正在复制指针，而不是对象。尝试这个：

*t2 = *t1;
于 2012-11-15T10:11:24.107 回答
2

您更改的代码正在复制指针，而不是Test对象本身。

t1, t2,t3并且t4都指向同一个对象，并且这个对象永远不会被复制。

于 2012-11-15T10:11:55.347 回答
2

这里有两件重要的事情：

  1. 类型和指向该类型的指针是两个非常不同的东西。
  2. 复制指针不会复制它指向的内容。

以这个块为例：

Test* t1 = new Test(), *t2;
t1->test();
// Works when it shouldnt work?
t2 = t1;

您的t1对象不会在此处复制。内存中只有一个类的实例，但现在有两个对它的引用。如果您调用delete，t2它将破坏该单个副本，并且您的其他引用 ,t1现在将指向无效的内存位置。

我不确定您是否可以阻止原始指针的复制，但即使您可以程序员可以轻松地将您Test*转换为void*，复制指针，然后将其转换回Test*. 如果您想防止复制任何类型的引用，您将需要使用智能指针和私有构造函数，这是一个全新的问题！

于 2012-11-15T10:15:25.337 回答
0

编译器生成的函数在C++ 标准中被称为特殊函数
乳清之所以如此调用，尤其是由于两个因素：
1.它们是由编译器生成的（如果不是由用户生成的）；
2.它们作为同一类的参数对象（〜destructor除外）。

因此，对于对象上的指针，不会生成此类函数。
同样在C++ 11 标准private中，您可以使用语句来代替声明要隐藏在区域中的函数delete。

于 2012-11-15T10:25:57.180 回答