动态分配内存的类定义拷贝构造函数和赋值运算符、C++幕后所做的事情以及禁止这些

朴灿烈づ我的快乐病毒、 2022-05-31 01:37 103阅读 0赞

## 1、C++编译可能默认生成一些函数 ##

> 通过它的时候。如果自定义类没有声明下列函数，C++编译器会声明自己的版本。这些函数是：一个拷贝构造函数，一个赋值运算符，一个析构函数，一对取址运算符。另外，如果你没有声明任何构造函数，它也将为你声明一个缺省构造函数。

class Empty{ };
    //等同于以下
    class Empty { 
    public:
        Empty();//缺省默认构造函数，没有定义则自动生成
        Empty(const Empty& rhs);//拷贝构造函数
        ~Empty();//析构函数,是否为虚函数看下文说明
        Empty& operator=(const Empty& rhs);//赋值运算符
        Empty* operator&();//取址运算符
        const Empty* operator&() const;取址运算符
    };
    
    //下面定义立马需要用到，所以编译给你定义
    const Empty e1; //使用缺省构造函数析构函数
    
    Empty e2(e1); //使用拷贝构造函数，通过参数匹配
    Empty e3 = e2; //使用拷贝构造函数
    
    e2 = e1; //使用赋值运算符
    Empty *pe2 = &e2; //使用(非const版本)取址运算符
    const Empty *pe1 = &e1;//使用(const版本)取址运算符

缺省构造函数和析构函数实际上什么也不做，它们只是让你能够创建和销毁类的对象。缺省取址运算符只是返回对象地址。  
解释拷贝构造函数：

template<class T>
    class NamedObject {
    public:
        NamedObject(const char *name, const T& value);
        NamedObject(const string& name, const T& value);
    private:
        string nameValue;
        T objectValue;
    };//生成一个拷贝构造函数，一个赋值运算符，一个析构函数，一对取址运算符，没有构造函数
    
    NamedObject<int> no1("Smallest Prime Number", 2);
    NamedObject<int> no2(no1);
    /* 调用拷贝构造函数: no2.nameValue初始化时将调用string的拷贝构造函数，参数为no1.nameValue。 no2.objectValue为int类型是通过从no1.objectValue拷贝每一个比特(bit)被初始化。 */

解释赋值运算符：

template<class T>
    class NamedObject {
    public:
        NamedObject(string& name, const T& value);
    private:
        string& nameValue; // 现在是一个引用，只可以引用一个对象
        const T objectValue; // 现在为const，只可以赋值一次
    };
    
    string newDog("Persephone");
    string oldDog("Satch");
    NamedObject<int> p(newDog, 2);
    NamedObject<int> s(oldDog, 29);
    p = s;//这里会报错，因为引用和const都不可以赋值二次。

## 2、动态分配内存的类定义拷贝构造函数和赋值运算符 ##

以下例子是没有自定义拷贝构造和赋值运算符出现的问题：

// 一个很简单的 String 类
    class String {
    public:
        String(const char *value){
        if (value) {
                data = new char[strlen(value) + 1];
                strcpy(data, value);
            }else{
                data = new char[1];
                *data = '\0';
            }
        }
        ~String(){
            delete [] data;//删除动态分配
        }
        //没有定义拷贝构造函数和operator=，编译器给你定义
    private:
        char *data;
    };
    
    //用户操作，可能出现问题
    String a("Hello"); //定义并构造a
    { //开一个新的生存空间
        String b("World"); // 定义并构造 b
        b = a;//执行operator=，直接将a.data拷贝给b.data
    } //离开生存空间, 调用b的析构函数，释放了b.data内存空间，此时a对象也不存在了
    String c = a; //调用生成的拷贝构造函数，但是c.data的值不能确定，因为a已经被b释放了。调用很可以出现内存错误。
    
    
    //如下操作也出现类似问题
    void doNothing(String localString)
    {
    
    }
    String s = "The Truth Is Out There";//将字符串拷贝给了
    doNothing(s);//生成临时对象调用拷贝构造localString=s，离开doNothing，localString调用析构函数，那么s地址空间也释放了

解决上述问题：  
解决指针混乱问题的方案在与只要类里有指针时，就要写自己版本的拷贝构造函数和赋值操作符函数。

## 3、如果不想使用隐式生成的函数就要显式地禁止 ##

template<class T>
    class Array {
    private:
        Array& operator=(const Array& rhs);
    };

直接将可以隐式生成的函数，声明成private即可，为了防止内部函数调用，我们可以不去定义这些函数。当用户试图对Array对象执行赋值操作时，编译器会不答应；当你自己无意间在成员或友元函数中调用它时，链接器会嗷嗷大叫。