c++——类的继承（派生）

一、c++中的继承

1.可以在已有类的基础上添加功能

2.可以给类添加数据

3.可以修改类的方法行为

基类：从一个类派生出另一个类时，原始类称为基类，继承类称为派生类。

二、继承demon（参考自c++书籍）

#include<iostream>
#include<string>

using std::string;
using namespace std;

class Table
{
	private:
		string firstname;
		string lastname;
		bool hasTable;
	public:
		Table (const string & fn = "name",const string & ln = "none",
		       bool ht = false);
		void Name() const;
		bool HasTable() const { return hasTable;}
		void RestTable(bool v) { hasTable = v;}; 
};

//成员列表初始化语法
Table::Table(const string & fn,const string & ln,bool ht):firstname(fn),lastname(ln),hasTable(ht)
{
}

void Table::Name() const
{
	std::cout<<lastname<<","<<firstname;
}


class RatedPlayer : public Table
{
	private:
		unsigned int rating;
	public:
		RatedPlayer(unsigned int r = 0,const string & fn = "none",const string & ln = "none",
			    bool ht = false);
		RatedPlayer(unsigned int r,const Table & tp);
		unsigned int Rating() const { return rating; }
		void RestRating(unsigned int r) { rating = r; }
};

/************************************************************************
**关于派生类构造函数要点
**1.首先创造基类对象；
**2.派生类构造函数应通过成员初始化列表将基类信息传给基类构造函数；
**3.派生类构造函数应初始化派生类新增的数据成员
**【注】：创建派生类构造函数时应先调用基类的构造函数再调用派生类构造函数
**      派生类对象消亡时，先调用派生类析构函数，再调用基类的析构函数
*************************************************************************/
RatedPlayer::RatedPlayer(unsigned int r,const string & fn,const string & ln,bool ht) : Table(fn,ln,ht)
{
	rating = r;
}

RatedPlayer::RatedPlayer(unsigned int r,const Table & tp) : Table(tp),rating(r)
{
}


int main()
{
	using std::cout;
	Table player1("chuck","Blizzard",true);
	Table player2("Tara","Boomdea",false);

	RatedPlayer rplayer1(1140,"Mallory","Duck",true);

	player1.Name();
	if(player1.HasTable())
		cout<<":has a Table.\n";
	else
		cout<<"hasn`t a table.\n";

	player2.Name();
	if(player2.HasTable())
		cout<<":has a Table.\n";
	else 
		cout<<":has`t a Table.\n";

	cout << "Name :";
	rplayer1.Name();
	cout << "; Rating: "<< rplayer1.Rating() << endl;


	RatedPlayer rplayer2(5233,player1);
	cout << "Name:";
	cout << "Rating: "<<rplayer2.Rating() << endl;
	return 0;
}

运行结果：

c++——类的继承（派生）

三、派生类和基类之间的特殊关系

派生类对象可以使用基类的方法，条件是方法不是私有的

基类指针可以在不进行显式类型转换的情况下指向派生类对象

基类引用可以在不进行显示类型转换的情况下引用派生类对象

以上示demon为例子

Table & rt = rplayer;
Table * pt = rplayer;
rt.Name(); //引用调用
pt->Name();//指针使用
【注】1.基类指针只能调用基类方法，不能调用派生类方法
	 2.不可以将基类的地址赋给派生类引用和指针

基类引用定义的函数或指针参数可用于基类对象或派生类对象

void Show(const Table & rt)
{
	using std::cout;
	cout << "Name: ";
	rt.Name();
	cout << "\nTable: ";
	if(rt.HasTable())
		cout << "yes\n";
	else
		cout << "no\n";
}
//player1 ---基类对象
//rplayer1 --派生类对象
Show(player1);  //argument
Show(rplayer1);  //argument

可以将基类对象初始化为派生类对象

可以将派生类对象赋给基类对象

四、继承：is-a关系

c++3种继承方式：

公有继承、保护继承、私有继承

1.公有继承：

建立的是is-a的关系，即派生类对象也是一个基类对象

is-a-kind-of：

往派生类中添加特性，属于is-a-kind-of关系

has-a：

例如fruit类和lunch类，lunch类可以包含furit类，但是furit类不能派生lunch类在午餐中添加水果（午餐中可以有水果，但水果不能包含全部的午餐属性）

五、多态公有继承

实现多有公态的重要机制

1.在派生类中重新定义基类的方法
2.使用虚方法

1.virtual关键字

virtual

在英文中表示“虚”、“虚拟”的含义。c++中的关键字“virtual”用于表示虚函数与虚基类。

1-1虚函数

class Brass
{
private:
	std::string fullName;
	long acctNum;
	double balance;
public:
	Brass(const std::string & s = "Nullbody", long an = -1, double bal = 0.0);//构造函数
	void Deposit(double amt);//存款
	virtual void Withdraw(double amt);//取款  虚函数
	double Balance() const;//余额
	virtual void  ViewAcct() const;
	virtual ~Brass();//析构函数
};
【注】如果派生类有一个析构函数，基类必须定义一个析构函数

//派生类
class BrassPlus : public Brass
{
private:
	double maxLoan;//最高借款额
	double rate;
	double owesBank;
public:
	BrassPlus(const sdt::string & s = "Nullbody",long an = -1,double bal = 0.0,double ml = 500,double r = 0.11125);
	BrassPlus(const Brass & ba, double ml = 500,double r = 0..11125);
	virtual void ViewAct() const;
	virtual void Withdraw(double amt);//取款
	void ResetMax(double m) { maxLoan = m };
	void ResetRate(double r) { rate = r; }//利率
	void ResetOwes() { owesBank = 0; }//负债 
};


使用virtual与未使用virtual关键字对比

/**未使用virtual**/
Brass dom("Brass",11224,5000.00);
BrassPlus dop("BraasP",111222,6000.01);
Brass & b1 = dom;
Brass & b2 = dop;
b1.ViewAct();//使用基类Brass方法
b2.ViewAct();//使用基类Brass方法

/**使用virtual**/Brass dom("Brass",11224,5000.00);
BrassPlus dop("BraasP",111222,6000.01);
Brass & b1 = dom;
Brass & b2 = dop;
b1.ViewAct();//使用基类Brass方法
b2.ViewAct();//使用派生类BrassPlus方法

银行存取款demon（参考自c++教程）

#include<iostream>
#include<string>

class Brass
{
private:
	std::string fullName;
	long acctNum;
	double balance;
public:
	Brass(const std::string & s = "Nullbody", long an = -1, double bal = 0.0);//构造函数
	void Deposit(double amt);//存款
	virtual void Withdraw(double amt);//取款  虚函数
	double Balance() const;//余额
	virtual void  ViewAcct() const;
	virtual ~Brass();//析构函数
};

//派生类
class BrassPlus : public Brass
{
private:
	double maxLoan;//最高借款额
	double rate;
	double owesBank;
public:
	BrassPlus(const std::string & s = "Nullbody",long an = -1,double bal = 0.0,double ml = 5000,double r = 0.11125);
	BrassPlus(const Brass & ba, double ml = 5000,double r = 0.11125);
	virtual void ViewAcct() const;
	virtual void Withdraw(double amt);//取款
	void ResetMax(double m) { maxLoan = m; }
	void ResetRate(double r) { rate = r; }//利率
	void ResetOwes() { owesBank = 0; }//负债 
};



using std::cout;
using std::endl;
using std::string;

typedef std::ios_base::fmtflags format;
typedef std::streamsize precis;
format setFormat();
void restore(format f, precis p);

Brass::Brass(const string & s,long an,double bal)
{
	fullName = s;
	acctNum = an;
	balance = bal;
}

//存款
void Brass::Deposit(double amt)
{
	if (amt < 0)
		cout << "存款须为正"<<endl;
	else
		balance += amt;
}

//取款
void Brass::Withdraw(double amt)
{
	format initialState = setFormat();
	precis prec = cout.precision(2);

	if (amt < 0)
		cout <<"取款额须为正"<<endl;
	else if(amt <= balance)
		balance -= amt;
	else
		cout <<"账户余额："<<balance<<" | 取款额："<< amt <<"| 取款额度超过账户余额，取款失败" << endl;
	restore(initialState,prec);
}

double Brass::Balance() const
{
	return balance;
}

//查看客户信息
void Brass::ViewAcct() const
{
	format initialSate = setFormat();
	precis prec = cout.precision(2);
	cout << "客户: " << fullName << endl;
	cout << "账户 Acount Number: " << acctNum <<endl;
	cout << "余额 Balance : " << balance <<endl;
	restore(initialSate,prec);
}

Brass::~Brass()
{

}

//派生类的实现
BrassPlus::BrassPlus(const string & s,long an,double bal,double ml, double r) : Brass(s,an,bal)
{
	maxLoan = ml;
	owesBank = 0.0;
	rate = r;
}

BrassPlus::BrassPlus(const Brass & ba,double ml, double r) : Brass(ba)
{
	maxLoan = ml;
	owesBank = 0.0;
	rate = r;
}

//查看借款信息
void BrassPlus::ViewAcct() const
{
	format initialSate = setFormat();
	precis prec = cout.precision(2);

	Brass::ViewAcct();
	cout << "最大借款额度："<< maxLoan << endl;
	cout << "账户已借款：" << owesBank << endl;
	cout << "利率：" << 100 * rate <<"%\n";
	restore(initialSate, prec);
}

//取款
void BrassPlus::Withdraw(double amt)
{
	format initialSate = setFormat();
	precis prec = cout.precision(2);

	double bal = Balance();
	if(amt <= bal )
		Brass::Withdraw(amt);
	else if (amt <= bal + maxLoan - owesBank )
	{
		double advance = amt - bal;
		owesBank += advance * (1.0+rate);
		cout << "预支取 ：" << advance << endl;
		cout << "最后须偿还利息：" << advance *rate << endl;
		Deposit(advance);
		Brass::Withdraw(amt);
	}
	else
		cout << "取款超出了限制" << endl;
	restore(initialSate,prec);
}

//将浮点值得输出模式设置为定点
format setFormat()
{
	return cout.setf(std::ios_base::fixed,std::ios_base::floatfield);
}

//重置格式和精度
void restore (format f,precis p)
{
	cout.setf(f,std::ios_base::floatfield);
	cout.precision(p);
}


int main()
{
	Brass B_Object("张三",888999,4000.00);
	BrassPlus P_Object("李四",666888,3000.00);

	B_Object.ViewAcct();
	P_Object.ViewAcct();
	cout << endl;

	
	cout << "存款1000到李四账户\n";
	P_Object.Deposit(1000.00);
	cout<<"nwe balance si "<<P_Object.Balance() << endl;

	cout << "\n张三取款5000\n";
	B_Object.Withdraw(5000.00);
	B_Object.ViewAcct();

	cout << "\n李四取款8000\n";
	P_Object.Withdraw(8000.00);
	P_Object.ViewAcct();
	
	return 0;
}

运行结果：

c++——类的继承（派生）

六、关键字protected

关键字protected：

关键字protected和private相似，在类外只能用公有类成员来访问protected部分的类成员。 派生类可以直接访问基类的保护部分成员，但不能直接访问私有成员

七、使用动态内存分配和友元示例

#include<iostream>
#include<cstring>

//基类
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);//友元重载<<
};

//派生类
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);
};

//派生类
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);
};

/**基类的实现**/
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(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;
}


/**派生类2**/
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 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;
}


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

	baseDMA shirt("Portabelly",8);//对象衬衣
	lacksDMA balloon("read","Blimpo",4);//对象气球
	hasDMA map("Mercator","Buffalo keys",5);//地图对象

	cout << "显示基类对象信息：\n";
	cout << shirt << endl;

	cout << "显示lacksDMA类对象信息：\n";
	cout << balloon << endl;

	cout << "显示hasDMA类对象信息：\n";
	cout << map << endl;


	lacksDMA balloon2(balloon);
	cout << " balloon2 copy from balloon:\n";
	cout << balloon2<<endl;

	hasDMA map2;
	map2 = map;
	cout << "map2 = map,map2 is \n";
	cout << map2<<endl;
	
	return 0;
}

运行结果：

c++——类的继承（派生）

c++——类的继承（派生）

继续阅读

C语言第四章自述2第四章选择结构程序设计

面试题:vector和map的区别，异同。空间分布，100万数据存哪个比较合适。一、迭代器区别二、vector三、Map、Set四、vector_map 为什么比map效率高五、如何选择六、容器选择原则七、效率对比

C++ 多线程用条件变量确定线程的执行顺序而不是使用 sleep(1)

POJ 1284 Primitive Roots (欧拉函数&原根定理)

CQ V1.0分词bates(基于双数组tire树)—应该是目前最快的中文分词算法

成员函数初始化列表

2021-08-13c++——类之操作符重载

swmm与lisflood-fp源码如何一起编译 CMake命令

Windows下VS开发环境环境安装工程项目设置关于Debug和Release的提示

一文看懂字符串的加减乘除

C++ 第十五周报告1--《冒泡法排序》

C++实现简单顺序表

C经典书籍笔记——C陷阱与缺陷②(语法陷阱之优先级)一、错误案列二、优先级规律

线性表之顺序表的实现

C++判断素数、求最大公约数代码判断一个数是否为素数求两个数的最大公约数

SequoiaDB巨杉数据库C++驱动概述