C++人该知道的N个问题与做法：了解C++类偷偷干的那些事，如何拒绝它

左手的ㄟ右手 2022-12-04 09:21 115阅读 0赞

## 了解C++默默编写并调用哪些函数 ##

当你创建一个类，但是如果你自己没声明其中一些东西,编译器就会为它声明(编译器版本的)一个拷贝构造函数、一个 copy 操作符和一个析构函数。此外如果你没有声明任何构造函数,编译器也会为你声明一个 默认构造函数。所有这些函数都是 public且 inline。

例：当你写下class Empty\{ \}；

就相当于你写下了：

Class Empty 
    {
     public:
        Empty() {...}                  // 默认构造函数
        Empty(const Empty& rhs){...}   //拷贝构造函数
        ~Empty(){...}                  //析构函数
        Empty& operator=(const Empty& rhs){...}   // copy 操作符.
    };

**当这些函数被调用的时候，它们才会被编译器创建出来**,如下代码可以使上述每个函数均生成；

Empty e1;        //默认构造函数（销毁调用析构）
    Empty e2(e1);    //拷贝构造
    e2 = e1;         //拷贝构造符

如果你的类中写了构造函数，但是没有拷贝构造等，编译器会自动给你创建拷贝构造等，但一般来说只有代码合法且可以证明其有意义的才会被生成。万一这两个条件中有一个不符合，则编译器会拒绝生成operator=；

例：成员变量是一个引用

template<class T>
    class Name
    {
     public:
        Name(std: strings name, const T& value);    //并未声明 operator
     private:
        string& namevalue;
        const T objectvalue;
    };

现在考虑下面会发生什么事?

string new("new");
    string old("old");
    Name<int>p(new,2);
    Name<int>s(old,3);
    
    p = s;

刚开始p.name和s.name都指向各自的string对象，当p=s之后，p.name是指向s.name的那个string吗？

当然不是，因为C++不允许让引用改指向不同的对象。所以最好的方法就是自己定义。

## 如何拒绝让编译器自动生成 ##

假设有有一个叶子类：class Leaf \{...\}

世界上没有两片完全相同的叶子，因此我们认为，为Leaf的对象进行拷贝是没有意义的，因为你无法复制一个独一无二的东西，所以你想让以下代码无法编译通过：

Leaf L1;
    Leaf L2;
    Leaf L3(L1);   //企图拷贝L1
    L1 = L2;       //企图拷贝L2；

通常如果你不希望 class支持某特定功能,只要不声明对应函数就是了。但这个策略对copy构造函数和copy操作符却不起作用,因为上面已经说明，如果你不声明它们,当尝试调用它们时,编译器会为你声明它们。

这把你逼到了一个困境。如果你不声明copy构造函数或 copy操作符,编译器可能为你产出一份,于是你的class支持copy,如果你声明它们,你的 class还是支持 copy，但你的目的却是要阻止 copy。

> 一个地方可以入手，因为所有编译器生成的函数都是 public.为阻止这些函数被创建出来你得自行声明它们,但这里并没有什么需求使你必须将它们声明为 public.因此你可以将copy构造函数或 copy操作符声明为 private.明确的声明一个成员函数来阻止编译器暗自创建其专属版本，并且令这些函数为 private,阻止调用它。

一般而言这个做法也并不绝对安全,因为 member函数和 friend函数还是可以调用你的 private函数。除非你够聪明,不去定义它们,那么如果某些人不慎调用任何一个,会获得一个连接错误( linkage error)。

实现方式:

class Leaf
    {
     public:
        ...
     private:
        Leaf(const Leaf& );    //参数名称并非必要，只不过大家习惯写出来
        Leaf& operator=(const Leaf& );   //只声明
    };

其他做法：

将连接期错误移至编译期是可能的(而且那是好事,毕竟越早侦测出错误越好),只要将copy构造函数和 copy操作符声明为 private就可以办到,但不是在 Leaf自身,而是在一个专门为了阻止 copying动作而设计的 base class，这个 base class 非常简单：

class Uncopyable
    {
     protected:        //允许对象构造和析构
        Uncopyable() { }
        ~Uncopyable() { }
     private:
        Uncopyable(const Uncopyable& );    //但阻止 copy
        Uncopyable& operator=(const Uncopyable& );
    };

为求阻止Leaf对象被拷贝,我们可以做的就是继承 Uncopyable：

class Leaf: private Uncopyable {...};
    //class不再声明copy构造函数或copy操作符

### 总结： ###

> 编译器可以暗自为 class 创建 default构造函数、copy构造函数、copy操作符,以及析构函数。
> 
> 为阻止编译器自动提供的功能,可将相应的成员函数声明为 private并且不予实现。或使用像 Uncopyable这样的 base class也是一种做法；