关于继承和动态内存分配

#include

using namespace std;

//基类

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 ostream & operator<<(ostream& os,const baseDMA& rs); //友元

};

//派生类 没有动态内存分配

class lackDMA : public baseDMA

{

private:

enum{COL_LEN=40};

char color[COL_LEN];

public:

lackDMA(const char* c=“blank”,const char* l=“null”,int r=0);

lackDMA(const char*c,const baseDMA& rs);

friend ostream & operator<<(ostream& os,const lackDMA& rs);

};

//派生类 有动态内存分配

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 ostream & operator<<(ostream& os,const hasDMA & rs);

};

#include “45.h”

#include

//类成员变量是动态内存分配 使用new动态分配

baseDMA::baseDMA(const char* l, int r)

{

label = new char[strlen(l)+1];

strcpy(label, l);

rating = r;

}

baseDMA::baseDMA(const baseDMA& rs)

{

label = new char[strlen(rs.label)+1];

strcpy(label, rs.label);

rating = rs.rating;

}

//析构函数 释放new出来的内存

baseDMA::~baseDMA()

{

delete[] label;

}

//赋值运算符

baseDMA & baseDMA::operator=(const baseDMA& rs)

{

if (this == &rs)

{

return *this;

}

delete[] label; //将原来类分配的内存空间释放掉

label = new char[strlen(rs.label)+1];
strcpy(label, rs.label);
rating = rs.rating;
return *this;
           

}

//输出运算符 就是将内容存储到ostream的变量os中

ostream& operator<<(ostream& os, const baseDMA& rs)

{

os << “Label:” << rs.label << endl;

os << “Rating:” << rs.rating << endl;

return os;

}

//

//lackDMA派生类 疑问，这种情况下一定要初始化基类吗 如果是没有的参数的默认构造函数的情况呢

//回答：基类的构造函数是有参的，派生类的构造函数需要对基类进行初始化

//这里使用成员初始化列表

lackDMA::lackDMA(const char* c, const char* l, int r)

:baseDMA(l, r)

{

strncpy(color, c,COL_LEN-1);

color[COL_LEN-1] = ‘\0’; //字符串最后一个字符一定是结束符

}

lackDMA::lackDMA(const char*c, const baseDMA& rs) //参数里有拷贝构造函数

: baseDMA(rs)

{

strncpy(color, c, COL_LEN - 1);

color[COL_LEN-1] = ‘\0’;

}

ostream & operator<<(ostream& os, const lackDMA& rs)

{

os << (const baseDMA&)rs; //派生类调用基类友元 使用强转

os << “color:” << rs.color << endl;

return os;

}

//

hasDMA::hasDMA(const char* s, const char* l, int r)

:baseDMA(l,r)

{

style = new char[strlen(s)+1];

strcpy(style, s);

}

hasDMA::hasDMA(const char* s, const baseDMA& rs)

:baseDMA(rs)

{

style = new char[strlen(s)+1];

strcpy(style, s);

}

hasDMA::hasDMA(const hasDMA& hs)

:baseDMA(hs) //注意一下这边 调用基类默认构造函数

{

style = new char[strlen(hs.style)+1];

strcpy(style, hs.style);

}

hasDMA::~hasDMA()

{

delete[] style;

}

hasDMA & hasDMA::operator=(const hasDMA & rs)

{

if (this == &rs)

{

return *this;

}

baseDMA::operator=(rs); //使用作用域解析符 调用基类赋值函数

delete[] style;

style = new char[strlen(rs.style)+1];
strcpy(style, rs.style);
return *this;
           

}

ostream & operator<<(ostream& os, const hasDMA & rs)

{

os << (const baseDMA&)rs; //强制类型转换(const baseDMA&)rs

os << “style” << rs.style << endl;

}