13.7 继承和动态内存分配

阳光开朗男孩

已于 2024-05-26 22:39:47 修改

阅读量190

点赞数

分类专栏： C++ Primer Plus 文章标签： c++ 开发语言后端

于 2021-11-08 16:02:39 首次发布

本文链接：https://blog.csdn.net/qq_36314864/article/details/121207354

版权

C++ Primer Plus 专栏收录该内容

39 篇文章 2 订阅

订阅专栏

本文详细探讨了当基类和派生类涉及动态内存分配时，析构函数、复制构造函数和赋值运算符的实现。对于不使用new的派生类lacksDMA，其默认构造函数、析构函数和赋值运算符已经足够。而对于使用new的派生类hasDMA，需要定义显式的析构函数、复制构造函数和赋值运算符以正确处理内存管理。文章还讨论了友元函数如何在派生类中访问基类的私有成员。

摘要由CSDN通过智能技术生成

派生类不使用new

假设基类使用了动态内存分配：

class baseDMA
{
private:
	char * label;
	int rating;

public:
	baseDMA(const char * l = "null", int r = 0);
	baseDMA(const baseDMA & rs);
	virtual ~baseDMA();
	baseDMA & operator=(const baseDMA & rs);
	...
};

声明中包含了构造函数使用new时需要的特殊方法：析构函数、复制构造函数和重载赋值运算符。

现在，从baseDMA派生出lackDMA类，而后者不使用new，也未包含其他一些不常用的、需要特殊处理的设计特性：

class lacksDMA : public baseDMA
{
private:
	char color[40];

public:
	...
};

不需要为lackDMA类定义显示析构函数、复制构造函数和赋值运算符。

析构函数：如果没有定义析构函数，编译器将定义一个不执行任何操作的默认构造函数。实际上，派生类的默认构造函数总是要进行一些操作：执行自身的代码后调用基类析构函数。因为我们假设lackDMA成员不需执行任何特殊操作，所以默认析构函数是合适的。

复制构造函数：默认复制构造函数执行成员复制，这对于动态内存分配来说是不合适的，但对于lacksDMA成员来说是合适的。因此只需考虑继承的baseDMA对象。成员复制将根据数据类型采用相应的复制方式，将long复制到long中通过使用常规赋值完成的，但复制类成员或继承的类组件时，则是使用该类的复制构造函数完成的。lacksDMA类的默认复制构造函数使用显式baseDMA复制构造函数来复制lacksDMA对象的baseDMA部分。默认复制构造函数对于lacksDMA成员是合适的，同时对于继承的baseDMA对象来说也是合适的。

对于赋值来说，类的默认赋值运算符将自动使用基类的赋值运算符来对基类组件进行赋值。

第二种情况：派生类使用new

假设派生类使用new：

class hasDMA : public baseDMA
{
private:
	char * style;
	
public:
	...
};

这种情况下，必须为派生类定义显式析构函数、复制构造函数和赋值运算符。

派生类析构函数自动调用基类的析构函数，故其自身的职责是对派生类构造函数执行工作的进行清理。因此，hasDMA析构函数必须释放指针style管理的内存，并依赖于baseDMA的析构函数来释放指针label管理的内存。

baseDMA::~baseDMA()
{
	delete []label;
}

hasDMA::~hasDMA()
{
	delete []style;
}

复制构造函数：BaseDMA的复制构造函数遵循用于char数组的常规模式，即使用strlen()来获悉存储C风格字符串所需的空间、分配足够的内存（字符数加上存储空字符所需的1字节）并使用函数strcpy()将原始字符串复制到目的地：

baseDMA::baseDMA(const baseDMA & rs)
{
	label = new char[std::strlen(rs.label) + 1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
}

hasDMA复制构造函数只能访问hasDMA的数据，因此它必须调用baseDMA复制构造函数来处理共享的baseDMA数据：

hasDMA::hasDMA(const hasDMA & hs) : baseDMA(hs)
{
	style = new char[std::strlen(hs.style) + 1];
	std::strcpy(style, hs.style);
}

成员初始化列表将一个hasDMA引用传递给baseDMA构造函数。没有参数类型为hasDMA引用的baseDMA构造函数，也不需要这样的构造函数。因为复制构造函数baseDMA有一个baseDMA引用参数，而基类引用可以指向派生类型。baseDMA复制构造函数将使用hasDMA参数的baseDMA部分来构造新对象的baseDMA部分。

赋值运算符，BaseDMA赋值运算符遵循常规模式：

baseDMA & baseDMA::operator=(const baseDMA & rs)
{
	if (this == &rs)
		return *this;
	delete[]label;
	label = new char[std::strlen(rs.label) + 1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
	return *this;
}

由于hasDMA也使用动态内存分配，所以它也需要一个显式赋值运算符。作为hasDMA的方法，它只能访问hasDMA的数据。然而，派生类的显式赋值运算符必须负责所有继承的baseDMA基类对象的赋值，可以通过显式调用基类赋值运算符来完成这项工作：

hasDMA & hasDMA::operator=(const hasDMA & hs)
{
	if (this == &hs)
		return *this;
	baseDMA::operator=(hs);
	delete[]style;
	style = new char[std::strlen(hs.style) + 1];
	std::strcpy(style, hs.style);
	return *this;
}

下面语句有点奇怪：

baseDMA::operator=(hs);

但通过使用函数表示法，而不是运算符表示法，可以使用作用域解析运算符。实际上，该句含义如下：

*this = hs; //use baseDMA::operator=()

使用后面代码时，编译器将使用hasDMA::operator=()，从而形成递归调用。使用函数表示法使得赋值运算符被正确调用。

当基类和派生类都采用动态内存分配时，派生类的析构函数、复制构造函数、赋值运算符都必须使用相应的基类方法来处理基类元素。

对于析构函数，这是自动完成。对于构造函数，这是通过在初始化成员列表中调用基类的复制构造函数来完成的；如果不这样做，将自动调用基类的默认构造函数。

对于赋值运算符。这是通过使用作用域解析运算符显式调用基类的赋值运算符来完成的。

dma.h

#ifndef DMA_H_
#define DMA_H_
#include <iostream>

//基类
class baseDMA
{
private:
	char * label;
	int rating;

public:
	baseDMA(const char * l = "null", int r = 0);
	baseDMA(const baseDMA & rs);
	virtual ~baseDMA();
	baseDMA & operator=(const baseDMA & rs);
	friend std::ostream & operator<<(std::ostream & os, const baseDMA & rs);
};

//lacksDMA
class lacksDMA : public baseDMA
{
private:
	enum { COL_LEN = 40 };
	char color[COL_LEN];

public:
	lacksDMA(const char * c = "blank", const char * l = "null", int r = 0);
	lacksDMA(const char * c, const baseDMA & rs);
	friend std::ostream & operator<<(std::ostream & os, const lacksDMA & rs);
};

//hasDMA
class hasDMA : public baseDMA
{
private:
	char * style;
	
public:
	hasDMA(const char * s = "none", const char * l = "null", int r = 0);
	hasDMA(const char * s, const baseDMA & rs);
	hasDMA(const hasDMA & hs);
	~hasDMA();
	hasDMA & operator=(const hasDMA & rs);
	friend std::ostream & operator<<(std::ostream & os, const hasDMA & rs);
};
#endif

dma.cpp

#include "dma.h"
#include <cstring>
#include <string.h>

//baseDMA
baseDMA::baseDMA(const char * l, int r)
{
	label = new char[std::strlen(l) + 1];
	std::strcpy(label, l);
	rating = r;
}

baseDMA::baseDMA(const baseDMA & rs)
{
	label = new char[std::strlen(rs.label) + 1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
}

baseDMA::~baseDMA()
{
	delete []label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs)
{
	if (this == &rs)
		return *this;
	delete[]label;
	label = new char[std::strlen(rs.label) + 1];
	std::strcpy(label, rs.label);
	rating = rs.rating;
	return *this;
}

std::ostream & operator<<(std::ostream & os, const baseDMA & rs)
{
	os << "Label: " << rs.label << std::endl;
	os << "Rating: " << rs.rating << std::endl;
	return os;
}

//lacksDMA
lacksDMA::lacksDMA(const char * c, const char * l, int r) : baseDMA(l, r)
{
	std::strncpy(color, c, 39);
	color[39] = '\0';
}

lacksDMA::lacksDMA(const char * c, const baseDMA & rs) : baseDMA(rs)
{
	std::strncpy(color, c, COL_LEN - 1);
	color[COL_LEN - 1] = '\0';
}

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls)
{
	os << (const baseDMA &)ls;
	os << "Color: " << ls.color << std::endl;
	return os;
}

//hasDMA
hasDMA::hasDMA(const char * s, const char * l, int r) : baseDMA(l, r)
{
	style = new char[std::strlen(s) + 1];
	std::strcpy(style, s);
}

hasDMA::hasDMA(const char * s, const baseDMA & rs) : baseDMA(rs)
{
	style = new char[std::strlen(s) + 1];
	std::strcpy(style, s);
}

hasDMA::hasDMA(const hasDMA & hs) : baseDMA(hs)
{
	style = new char[std::strlen(hs.style) + 1];
	std::strcpy(style, hs.style);
}

hasDMA::~hasDMA()
{
	delete []style;
}

hasDMA & hasDMA::operator=(const hasDMA & hs)
{
	if (this == &hs)
		return *this;
	baseDMA::operator=(hs);
	delete[]style;
	style = new char[std::strlen(hs.style) + 1];
	std::strcpy(style, hs.style);
	return *this;
}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs)
{
	os << (const baseDMA &)hs;
	os << "Style: " << hs.style << std::endl;
	return os;
}

派生类如何使用基类的友元：

friend std::ostream & operator<<(std::ostream & os, const hasDMA & rs);

作为hasDMA类的友元，该函数能够访问style成员。然而，还存在一个问题：该函数如不是baseDMA类的友元，那它如何访问成员lable和rating？使用baseDMA类友元函数operator<<()。因为友元不是成员函数，所以不能使用作用域解析运算符来指出要使用哪个函数？使用强制类型转换，以匹配原型时能够选择正确的函数。因此代码将参数const hasDMA &转换成类型为const baseDMA &参数：

std::ostream & operator<<(std::ostream & os, const hasDMA & hs)
{
	os << (const baseDMA &)hs;
	os << "Style: " << hs.style << std::endl;
	return os;
}

main.cpp

#include <iostream>
#include "dma.h"

int main()
{
	using std::cout;
	using std::endl;

	baseDMA shirt("Portabelly", 8);
	lacksDMA balloon("red", "Blimpo", 4);
	hasDMA map("Mercator", "Buffalo Keys", 5);
	cout << "Displaying baseDMA object:\n";
	cout << shirt << endl;
	cout << "Displaying lacksDMA object:\n";
	cout << balloon << endl;
	cout << "Displaying hasDMA object:\n";
	cout << map << endl;
	lacksDMA balloon2(balloon);
	cout << "Result of lacksDMA copy:\n";
	cout << balloon2 << endl;
	hasDMA map2;
	map2 = map;
	cout << "Result of hasDMA assignment:\n";
	cout << map2 << endl;
	return 0;
}