C++ day25 继承（五）继承和动态内存分配

╰+攻爆jí腚メ 2023-05-28 12:54 40阅读 0赞

### 文章目录 ###

*  当继承和动态内存分配搅和在一起，会有什么火花
 *   *  当基类没用new和delete(动态内存分配)
     *  当基类用了new和delete(动态内存分配)
     *   *  派生类不用动态内存分配
         *   *  派生类是否需要显示定义析构函数: no
             *  派生类是否需要显示定义复制构造函数: no
             *  派生类是否需要显示定义赋值运算符函数: no
         *  派生类也用动态内存分配
         *   *  派生类是否需要显示定义析构函数: yes
             *  派生类是否需要显示定义复制构造函数: yes
             *  派生类是否需要显示定义赋值运算符函数: yes
     *  示例
     *   *  代码
         *  错误
 *  什么不能被继承

# 当继承和动态内存分配搅和在一起，会有什么火花 #

## 当基类没用new和delete(动态内存分配) ##

继承和动态内存分配搅和在一起时，需要分四种情况，基类不用动态内存分配的话，派生类用或者不用，都是他自己的事，对基类并无影响，所以不予讨论。

截止目前，对继承的探讨中，基类一直都没用new和delete，即动态内存分配。也就是说，之前的基类都没有指针成员。这时候派生类用不用动态内存分配都随他们自己高兴，因为要用动态内存分配也是把new和delete用到他们自己新添的数据成员身上，和基类并无干系。

## 当基类用了new和delete(动态内存分配) ##

这是本文的主角了。

但是基类如果用了动态内存分配，那么基类最好是**定义一个显式的复制构造函数和赋值运算符成员函数**，因为**使用动态内存分配就说明这个类一定有指针成员**，以便于存储动态分配内存的地址，有指针成员的话，如果要用已有的对象初始化一个对象，或者对象之间赋值，就会分别调用复制构造函数和赋值运算符函数。前面说了，如果自己不显式定义这两个函数，编译器就会上手，自动定义两个默认版本，二者的默认版本都是使用成员复制，即浅复制，浅复制**会按照成员的数据类型来判断使用什么复制方法**，比如基本内置类型int, long就直接**赋值**，string类等类对象成员就**调用他们类的复制构造函数**进行复制。所以指针类型也是被像简单类型那样，直接赋值，于是就只是复制了地址的值，并没有复制真正的内容。于是被初始化的新对象或者被赋值的对象就会和源对象的指针成员指向同一各地址处的内容，而不是各自独占一个副本，只要其中任何一人先行更改指针指向的内容或被删除（过期），则另一人也随之玩完。

说了好长，总之有动态内存分配就一定有指针成员，有指针成员就一定要自己用深复制显式写复制构造函数和赋值运算符函数。

所以基类既然要用动态内存分配，那就必须用深复制显式写复制构造函数和赋值运算符函数。

### 派生类不用动态内存分配 ###

解答下面三个问题的关键：**基类对象实际上是派生类对象的一部分**，派生类对象包含了基类对象。甚至基类对象有点像派生类对象的一个成员，但是又是个没名字的成员，因为复制构造函数复制基类的数据成员时会调用基类的复制构造函数。

#### 派生类是否需要显示定义析构函数: no ####

自己定义析构函数的目的就是去释放用new分配内存的成员，前面说过，只要没有用动态内存分配，那么根本不用写析构函数，编译器提供的就足够了，就算自己非要写，也是空圆括号空花括号了事。因为类的对象的成员们都存在栈中，程序结束都会自动释放。

那么现在明确说了基类用了动态分配而派生类没用，派生类是否还是可以不定义析构函数呢？答案是：可以。

因为派生类不定义析构函数，会用编译器的默认析构函数，默认析构函数什么都不做，除了调用基类的析构函数。基类的析构函数就会释放派生类对象中基类对象的那部分用了动态内存分配的，于是问题解决了。

#### 派生类是否需要显示定义复制构造函数: no ####

不用。

一样的思路。派生类不定义，就使用编译器的默认复制构造函数，由于成员复制会根据成员的数据类型判断怎么复制，派生类对象中的基类对象成员就会通过调用基类的复制构造函数来复制，所以不会出问题。

#### 派生类是否需要显示定义赋值运算符函数: no ####

同上。

### 派生类也用动态内存分配 ###

解释了上面的情况，下面的答案也就有了。

#### 派生类是否需要显示定义析构函数: yes ####

需要自定义析构函数以delete派生类新增加的指针成员，即要用new分配内存的。不管是不是在构造函数中动用new去分配内存，析构函数都要delete。（有时候没在构造函数new，却在其他地方new了，不要简单一看构造函数没有new就不写析构函数了）

#### 派生类是否需要显示定义复制构造函数: yes ####

需要自定义复制构造函数以深复制派生类新增加的指针成员

#### 派生类是否需要显示定义赋值运算符函数: yes ####

需要自定义赋值运算符函数以深复制派生类新增加的指针成员

## 示例 ##

### 代码 ###

//baseDMA.h
    #ifndef BASEDMA_H_
    #define BASEDMA_H_
    
    #include <iostream>
    class baseDMA{ 
    private:
        char * label;
        int rating;
    public:
        baseDMA(const char * s = "null", int r = 0);
        baseDMA(const baseDMA & bd);//复制构造函数
        baseDMA & operator=(const baseDMA & bd);//赋值运算符函数
        virtual ~baseDMA();
        friend std::ostream & operator<<(std::ostream & os, const baseDMA & bd);//输出运算符，友元函数
    };
    
    //不用动态内存分配的派生类
    class lacksDMA : public baseDMA
    { 
    private:
        enum { LEN = 40};
        char color[LEN];
    public:
        lacksDMA(const char * s = "null", int r = 0, const char * c = "none");
        lacksDMA(const baseDMA & bd, const char * c = "none");
        //友元函数并不属于类，所以不能被继承，必须自己写哦
        friend std::ostream & operator<<(std::ostream & os, const lacksDMA & ld);
    };
    
    //用动态内存分配的派生类
    class hasDMA : public baseDMA
    { 
    private:
        char *style;
    public:
        hasDMA(const char * s = "null", int r = 0, const char * sty = "none");
        hasDMA(const baseDMA & bd, const char * sty = "none");
        ~hasDMA();//析构函数
        hasDMA(const hasDMA & hd);//复制构造函数
        hasDMA & operator=(const hasDMA & hd);//赋值运算符函数
        //友元函数并不属于类，所以不能被继承，必须自己写哦
        friend std::ostream & operator<<(std::ostream & os, const hasDMA & ld);
    };
    #endif // BASEDMA_H_

//baseDMA.cpp
    //派生类方法中用了很多强制类型转换，把派生类对象转换为基类对象，从而得到基类对象的部分
    #include <iostream>
    #include <cstring>
    #include "baseDMA.h"
    
    //baseDMA methods
    baseDMA::baseDMA(const char * s, int r)
    { 
        //label = s;//错误!!!传入的s只是传了内容，我们要新建内存以保存这个内容
        int len = std::strlen(s);
        label = new char[len + 1];
        std::strcpy(label, s);
        rating = r;
    }
    
    baseDMA::baseDMA(const baseDMA & bd)//复制构造函数
    { 
        //深复制
        int len = std::strlen(bd.label);
        label = new char[len + 1];
        std::strcpy(label, bd.label);
        //浅复制
        rating = bd.rating;
    }
    
    baseDMA & baseDMA::operator=(const baseDMA & bd)//赋值运算符函数
    { 
        if (this == &bd)
            return *this;
        delete [] label;
        //深复制
        int len = std::strlen(bd.label);
        label = new char[len + 1];
        std::strcpy(label, bd.label);
        //浅复制
        rating = bd.rating;
        return *this;
    }
    
    baseDMA::~baseDMA()
    { 
        delete [] label;
    }
    
    std::ostream & operator<<(std::ostream & os, const baseDMA & bd)
    { 
        os << "Label: " << bd.label << '\t'
           << "Rating: " << bd.rating;
        return os;
    }
    
    //lacksDMA methods
    lacksDMA::lacksDMA(const char * s, int r, const char * c):baseDMA(s, r)
    { 
        //color = c;//错误！！
        std::strncpy(color, c, LEN);
        color[LEN - 1] = '\0';//如果超过了程序不会把数组末尾元素设置为空字符
    }
    
    lacksDMA::lacksDMA(const baseDMA & bd, const char * c):baseDMA(bd)
    { 
        std::strncpy(color, c, LEN);
        color[LEN - 1] = '\0';
    }
    
    std::ostream & operator<<(std::ostream & os, const lacksDMA & ld)
    { 
        /* //复杂版，没重用代码 os << "Label: " << ld.label << '\n' << "Rating: " << ld.rating << '\n' << "Color: " << ld.color << '\n'; */
    
        //简洁版
        os << (const baseDMA &)ld
           << "\tColor: " << ld.color;
        return os;
    }
    
    //hasDMA methods
    hasDMA::hasDMA(const char * s, int r, const char * sty):baseDMA(s, r)
    { 
        style = new char[std::strlen(sty) + 1];
        std::strcpy(style, sty);
    }
    
    hasDMA::hasDMA(const baseDMA & bd, const char * sty):baseDMA(bd)
    { 
        style = new char[std::strlen(sty) + 1];
        std::strcpy(style, sty);
    }
    
    hasDMA::~hasDMA()//析构函数
    { 
        delete [] style;
    }
    
    //复制构造函数（简单版本，利用初始化成员列表）
    hasDMA::hasDMA(const hasDMA & hd):baseDMA((const baseDMA &)hd)
    { 
        //新成员
        style = new char[std::strlen(hd.style) + 1];
        std::strcpy(style, hd.style);
    }
    
    
    hasDMA & hasDMA::operator=(const hasDMA & hd)//赋值运算符函数
    { 
        if (this == &hd)
            return *this;
        //旧成员，这里高级了
        baseDMA::operator=((const baseDMA &)hd);//this对象自动成为第一个参数并被返回
        //新成员
        delete [] style;
        style = new char[std::strlen(hd.style) + 1];
        std::strcpy(style, hd.style);
        return *this;
    }
    
    std::ostream & operator<<(std::ostream & os, const hasDMA & hd)
    { 
        os << (const baseDMA &)hd;
        os << "\tStyle: " << hd.style;
        return os;
    }

//main.cpp
    #include <iostream>
    #include "baseDMA.h"
    void eatline();
    
    int main()
    { 
    	using std::cout;
    	using std::endl;
    
    	baseDMA map("grass", 5);
    	lacksDMA pot("curtain", 9, "pink");
    	hasDMA hat("wall", 7, "Chinese-style");
    
        cout << map << endl;
        cout << pot << endl;
        cout << hat << endl;
    
        baseDMA map2(map);
        baseDMA map3;
        map3 = map;
        cout << map2 << endl;
        cout << map3 << endl;
    
        lacksDMA pot2(pot);
        lacksDMA pot3;
        pot3 = pot;
        cout << pot2 << endl;
        cout << pot3 << endl;
    
        hasDMA hat2(hat);
        hasDMA hat3;
        hat3 = hat;
        cout << hat2 << endl;
        cout << hat3 << endl;
    
    	return 0;
    }
    
    void eatline()
    { 
        while (std::cin.get() != '\n')
            ;
    }

输出，可以看到三个类的构造函数，复制构造函数，赋值运算符函数和友元输出函数都运行良好，没有错误

Label: grass    Rating: 5
    Label: curtain  Rating: 9       Color: pink
    Label: wall     Rating: 7       Style: Chinese-style
    Label: grass    Rating: 5
    Label: grass    Rating: 5
    Label: curtain  Rating: 9       Color: pink
    Label: curtain  Rating: 9       Color: pink
    Label: wall     Rating: 7       Style: Chinese-style
    Label: wall     Rating: 7       Style: Chinese-style

### 错误 ###

*  方法文件的函数头竟然也写了**默认参数值**，我直接复制了函数原型们，忘记删除默认参数的默认值，不该犯这个错
 *  方法文件的定义中，虚析构函数的**virtual关键字**忘记删掉了，不该犯错
 *  方法文件的定义中，友元函数的**friend关键字**忘记删掉了，不该犯错
 *  方法文件的定义中，友元函数竟然也用类名和作用域解析运算符限定了，**友元函数并不属于这个类**，不该限定，不该犯错
 *  不知道可以用**强制类型转换获得派生类对象中包含的基类对象**
 *  在赋值运算符成员函数中，忘记一上来先看看两个参数是不是同一个，那样就不用麻烦后面的代码了。
 *  在赋值运算符成员函数中，**忘记delete** \[\] label，再重新分配内存。这会导致原来的label处的内存永远没法释放。
 *  在派生类的复制构造函数中调用基类的构造函数，这是不允许的。！！！要想显式调用，只可以用**初始化成员列表**的方法调用。

我对这一点很不熟悉，实际上，  
派生类的构造函数调用基类的构造函数都是通过初始化成员列表的方式进行的，  
派生类的构造函数调用基类的构造函数都是通过初始化成员列表的方式进行的，  
派生类的构造函数调用基类的构造函数都是通过初始化成员列表的方式进行的。

如果不在成员初始化列表显式调用基类构造函数，编译器就会自动调用基类的**默认**构造函数，所以编译器不允许  
我们这些无知小儿在派生类构造函数的函数体中**直接**调用基类构造函数，它会报错。

//这里出错很多，对初始化成员列表，构造函数，派生类的访问权限掌握不牢靠
    hasDMA::hasDMA(const hasDMA & hd)//复制构造函数
    { 
        //旧成员，调用基类复制构造函数即可
        //直接用类型转换得到基类对象
        //baseDMA::baseDMA((const baseDMA &)hd);//报错，不可以在派生类构造函数中直接调用基类的构造函数
    	//我的重用代码版本（思路正确，但走了远路）：构建一个基类对象，再代入到基类复制构造函数
        //baseDMA::baseDMA(baseDMA::baseDMA(hd.label, hd.rating));//这就更错误了，因为派生类方法中无法访问基类的私有数据成员！！！！
        //新成员
        style = new char[std::strlen(hd.style) + 1];
        std::strcpy(style, hd.style);
    }

*  深复制不是很会写，好几次都写错了。

# 什么不能被继承 #

先上一张总结图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]

就四个函数不可以被继承，挨个说  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]

*  友元函数

因为他根本不是类的一部分，你爸朋友的财产也让你继承？

但是我们仍然可以使用到基类的友元函数，**只需要把派生类指针或引用强制转换为基类指针或引用**即可，刚才的代码就这么做了：

std::ostream & operator<<(std::ostream & os, const lacksDMA & ld)
    { 
        os << (const baseDMA &)ld
           << "\tColor: " << ld.color;
        return os;
    }

std::ostream & operator<<(std::ostream & os, const hasDMA & hd)
    { 
        os << (const baseDMA &)hd;
        os << "\tStyle: " << hd.style;
        return os;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: /images/20230528/68ec347f3ccf4de9ae58ee728ce44db6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: /images/20230528/2ef8fde303fe403aaa9102cad39389cb.png