1.继承和动态内存分配
继承是怎样与动态内存分配(使用new和 delete)进行互动的呢?
例如,如果基类使用动态内存分配并重新定义赋值和复制构造函数,这将怎样影响派生类的实现呢?这个问题的答案取决于派生类的属性
如果派生类也使用动态内存分配,那么就需要学习几个新的小技巧。下面来看看这两种情况
1.第一种情況:派生类不使用new
假设基类使用了动态内存分配:
// Base Class Using DMA
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派生出 lacksDMA类,而后者不使用new,也未包含其他一些不常用的、需要特殊处理的设计特性:
// derived class without DMA
class lacksDMA: public baseDMA
{
private:
char color[40];
public:
};
是否需要为 lacksDMA类定义显式析构函数、复制构造函数和赋值运算符呢?不需要。
首先,来看是否需要析构函数。如果没有定义析构函数,编译器将定义一个不执行任何操作的默认构造函数。
实际上,派生类的默认构造函数总是要进行一些操作:执行自身的代码后调用基类析构函数。因为我们假设 lacksDMA成员不需执行任何特殊操作,所以默认析构函数是合适的。
接着来看复制构造函数。第12章介绍过,默认复制构造函数执行成员复制,这对于动态内存分配来说是不合适的,但对于新的 lacksDMA成员来说是合适的。
因此只需考虑继承的 baseDMA对象。要知道,成员复制将根据数据类型采用相应的复制方式,因此,将long复制到long中是通过使用常规赋值完成的;但复制类成员或继承的类组件时,则是使用该类的复制构造函数完成的。所以, lacksDMA类的默认复制构造函数使用显式 baseDMA复制构造函数来复制 lacksDMA对象的 baseDMA部分。
因此,默认复制构造函数对于新的 lacksDMA成员来说是合适的,同时对于继承的 baseDMA对象来说也是合适的。
对于赋值来说,也是如此。类的默认赋值运算符将自动使用基类的赋值运算符来对基类组件进行赋值。因此,默认赋值运算符也是合适的。
派生类对象的这些属性也适用于本身是对象的类成员。例如,第10章介绍过,实现 Stock类时,可以使用 string对象而不是char数组来存储公司名称。标准 string类和本书前面创建的 String类一样,也采用动态内存分配。现在,读者知道了为何这不会引发问题。 Stock的默认复制构造函数将使用 string的复制构造函数来复制对象的 company成员:Stock的默认赋值运算符将使用 string 的赋值运算符给对象的 company成员赋值;而 Stock的析构函数(默认或其他析构函数)将自动调用 string的析构函数。
2.第二种情况:派生类使用new
假设派生类使用了new:
// derived class with DMA
class hasDMA: public baseDMA
{
private:
char *style; // use new in constructors
public:
}
在这种情况下,必须为派生类定义显式析构函数、复制构造函数和赋值运算符。
下面依次考虑这方法派生类析构函数自动调用基类的析构函数,故其自身的职责是对派生类构造函数执行工作的进行清理。
因此, hasDMA析构函数必须释放指针 style管理的内存,并依赖于 baseDMA的析构函数来释放指针 label管理的内存。
baseDMA::~baseDMA() //takes care of baseDMA stuff
{
delete[] label;
}
hasDMA::~hasDMA() //takes care of hasDMA stuff
{
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;
}
由于 hasDMA也使用动态内存分配,所以它也需要一个显式赋值运算符。作为 hasDMA的方法,它只能直接访问 hasDMA的数据。然而,派生类的显式赋值运算符必须负责所有继承的 baseDMA基类对象的赋值,可以通过显式调用基类赋值运算符来完成这项工作,如下所示:
hasDMA & hasDMA::operator(const hasDMA &hs)
{
if (this == &hs)
return *this;
baseDMA::operator=(hs); // copy base portion
delete [] style;
style = new char[std::strlen(hs.style) + 1];
std::strcpy(style, hs.style);
return *this;
}
下述语句看起来有点奇怪
baseDMA::operator=(hs); // copy base portion
但通过使用函数表示法,而不是运算符表示法,可以使用作用域解析运算符。
实际上,该语句的含义如下:
*this = hs; // use baseDMA::operator=()
当然编译器将忽略注释,所以使用后面的代码时,编译器将使用 hasDMA::operator=(hs),从而形成递归调用。使用函数表示法使得赋值运算符被正确调用。
总之,当基类和派生类都采用动态内存分配时,派生类的析构函数、复制构造函数、赋值运算符都必须使用相应的基类方法来处理基类元素。
这种要求是通过三种不同的方式来满足的。
- 对于析构函数,这是自动完成的;
- 对于构造函数,这是通过在初始化成员列表中调用基类的复制构造函数来完成的:如果不这样做,将自动调用基类的默认构造函数。
- 对于赋值运算符,这是通过使用作用域解析运算符显式地调用基类的赋值运算符来完成的。
2.使用动态内存分配和友元的继承示例
为演示这些有关继承和动态内存分配的概念,我们将刚オ介绍过的 baseDMA、 lacksDMA和 hasDMA类集成到一个示例中。程序清单13.14是这些类的头文件。除了前面介绍的内容外,这个头文件还包含一个友元函数,以说明派生类如何访问基类的友元。
程序清单13.14 dma.h
/*
author:梦悦foundation
公众号:梦悦foundation
可以在公众号获得源码和详细的图文笔记
*/
// dma.h -- inheritance and dynamic memory allocation
#ifndef DMA_H_
#define DMA_H_
#include <iostream>
// Base Class Using DMA
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);
};
// derived class without DMA
// no destructor needed
// uses implicit copy constructor
// uses implicit assignment operator
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);
};
// derived class with DMA
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
程序清单13.15列出了类 baseDMA、 lacksDMA和 hasDMA的方法定义。
程序清单13.15 dma.cpp
/*
author:梦悦foundation
公众号:梦悦foundation
可以在公众号获得源码和详细的图文笔记
*/
// dma.cpp --dma class methods
#include "dma.h"
#include <cstring>
// baseDMA methods
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 methods
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 methods
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) // invoke base class copy constructor
{
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); // copy base portion
delete [] style; // prepare for new 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;
}
在程序清单13.14和程序清单13.15中,需要注意的新特性是,派生类如何使用基类的友元。例如,请考虑下面这个 hasDMA类的友元:
friend std::ostream & operators<<(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)
{
//强制类型转换来匹配 operator<<(ostream &, const baseDMA &)
os << (const baseDMA &) hs;
os << "Style: " << hs.style << std::endl;
return os;
}
程序清单13.16是一个测试类 baseDMA、 lacksDMA和 hasDMA的小程序。
程序清单13.16 usedma.cpp
/*
author:梦悦foundation
公众号:梦悦foundation
可以在公众号获得源码和详细的图文笔记
*/
// usedma.cpp -- inheritance, friends, and DMA
// compile with dma.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;
// std::cin.get();
return 0;
}
程序清单13.14~程序清单13.16组成的程序的输出如下:
book@book-desktop:~/meng-yue/c++/class_inherit/06$ g++ -o usedma usedma.cpp dma.cpp
book@book-desktop:~/meng-yue/c++/class_inherit/06$ ./usedma
Displaying baseDMA object:
Label: Portabelly
Rating: 8
Displaying lacksDMA object:
Label: Blimpo
Rating: 4
Color: red
Displaying hasDMA object:
Label: Buffalo Keys
Rating: 5
Style: Mercator
Result of lacksDMA copy:
Label: Blimpo
Rating: 4
Color: red
Result of hasDMA assignment:
Label: Buffalo Keys
Rating: 5
Style: Mercator
book@book-desktop:~/meng-yue/c++/class_inherit/06$