c++之类的继承入门

c++ — 类的继承入门

继承与派生概述：

1、保持已有类的特性而构造新类的过程称为继承；在已有类的基础上新增自己的特性而产生新类的过程称为派生
2、被继承的已有类称为基类（或父类）
3、派生出的新类称为派生类（或子类）
4、直接参与派生出某类的基类称为直接基类
5、基类的基类甚至更高层的基类称为间接基类
继承的目的： 实现设计与代码的重用
派生的目的： 原程序无法解决新问题时，需对原程序进行改造
单继承时派生类定义：
class 派生类名：继承方式 基类名
{
成员声明；
}

多继承时派生类定义：
class 派生类名：继承方式1 基类名1，继承方式2 基类名2… …
{
成员声明；
}
注：每一个继承方式仅用于限制对紧随其后之基类的继承

派生类构成：
1、吸收的基类成员
默认条件下派生类包含了全部基类中除构造和析构函数之外的所有成员，但c++11标准中规定可以用using语句继承基类构造函数。
2、改造的基类成员
如果派生类声明了一个某基类成员同名的新成员，则派生的新成员就隐藏或覆盖了外层同名成员
3、添加新的成员
增加的新功能和数据。

继承方式

不同继承方式的影响：
1、派生类成员对基类成员的访问权限
2、通过派生类对象对基类成员的访问权限

公有继承（public）

私有继承（private）

（若想调用基类的成员函数，可以在派生类中写一个成员函数，让这个函数去调用基类的成员函数，就可以用派生类的对象去间接调用基类的成员函数）

保护继承（protected）
protected成员的特点及作用：
1、对建立其所在类的对象来说，它与private成员的性质相同来说。
2、对于其派生类来说，它与public成员的性质相同。
3、既实现了数据隐藏，又方便继承，实现代码重用。

多继承：
（一个类可以用不同的继承方式继承不同的类）

#include <iostream>
using namespace std;

class A{
public:
	void setA(int x){
		a=x;
	}
	void showA(){
		cout<<a<<endl;
	}
private:
	int a;
};

class B{
public:
	void setB(int x){
		b=x;
	}
	void showB(){
		cout<<b<<endl;
	}
private:
	int b;
};

class C:public A,private B{      //多继承，公有继承A类，私有继承B类 
public:
	void setC(int,int,int);
	void showC(){
		cout<<c<<endl;
	}
private:
	int c;
};

void C::setC(int x,int y,int z){
	setA(x);
	setB(y);              //不管是公有继承还是私有继承，派生类都可以访问基类的公有成员 
	c=z;
}

int main()
{	
	C c;
	c.setA(4);
	c.showA();              //派生类的对象可以直接访问公有继承过来的类的非私有成员 
	c.setC(1,2,3);
	c.showC();
//	c.setB(5);      错误 
//	c.showB();      因为派生类的对象不能直接访问私有继承过来的基类的成员 
	return 0;
}

基类与派生类的类型转换

1.公有继承的派生类对象可以被当做基类的对象使用，反之则不可：
派生类的对象可以隐含转换为基类的对象
派生类的对象可以初始化基类的引用
派生类的指针可以隐含转换为基类的指针
2、通过基类对象名、指针只能使用从基类继承的成员

派生类的构造函数

默认情况下：
1、基类的构造函数不被继承
2、派生类需要定义自己的构造函数
如何初始化：
1、派生类新增成员：派生类定义构造函数初始化。
2、继承来的成员：自动调用基类构造函数进行初始化。
3、派生类的构造函数需要给基类的构造函数传递参数。
单继承时构造函数定义语法：
派生类名：：派生类名（基类所需的形参，本类所需的形参）：
基类名（参数表），本类成员初始化列表
{
//其他初始化；
}
例：

#include <iostream>
using namespace std;

class B{
public:
	B(){
		b=0;
		cout<<"B的默认构造函数"<<endl;
	}
	B(int i){
		b=i;
		cout<<"B的构造函数"<<endl; 
	}
	~B(){
		cout<<"B的析构函数"<<endl;
	}
	void print() const{
		cout<<b<<endl;
	}
private:
	int b;
};

class C:public B{      
public:
	C(){
		c=0;
		cout<<"C的默认构造函数"<<endl;
	}
	C(int,int);
	~C(){
		cout<<"C的析构函数"<<endl;
	}
	void print() const{
		B::print();
		cout<<c<<endl;
	}
private:
	int c;
};

C::C(int i,int j):B(i),c(j){
	cout<<"C的构造函数"<<endl;
}                                //单继承的构造函数定义

int main()
{	
	C c(4,5);
	c.print();
	return 0;
}

多继承时构造函数定义语法：
派生类名：：派生类名（参数表）：
基类名1（基类1初始化参数表），
基类名2（基类2初始化参数表），
… …
基类名n（基类n初始化参数表），
本类成员初始化参数表
{
//其他初始化；
}
注：

多继承且有对象成员时的派生类的构造函数定义语法：
派生类名：：派生类名（形参表）
基类名1（参数），基类名2（参数），… …，基类名n（参数），
本类成员和对象成员的初始化列表
{
//其他初始化
}

构造函数的执行顺序：

派生类的复制构造函数

若派生类未声明复制构造函数：
编译器会在需要时生成一个隐含的复制构造函数，先调用基类的复制构造函数，再为派生类新增的成员执行复制。
若派生类定义复制构造函数：
1、一般要为基类的复制构造函数传递参数；
2、复制构造函数只能接受一个参数，即用来初始化派生类定义的成员，也将被传递给基类的复制构造函数；
3、基类的复制构造函数的形参类型时基类对象的引用，实参可以是派生类对象的引用。
例如：
C：：C（const C &c1）：B（c1）{ }

派生类的析构函数

1、析构函数不被继承，派生类如果需要则需自行声明析构函数
2、声明方法与无继承关系时类的析构函数相同
3、不需要显式地调用基类的析构函数，系统会自动隐式调用
4、先执行派生类析构函数的函数体，再调用基类的析构函数

访问从基类继承的成员

当派生类与基类有相同成员时：
1、若未特别限定，则通过派生类的对象使用的是派生类中的同名成员。
2、若想通过派生类对象访问基类中的同名成员，应使用基类名和作用域操作符（：：）来限定。
二义性问题：
1、如果从不同基类继承了同名成员，但是在派生类中没有定义同名成员，则访问该成员时会出现二义性问题。不能再用 “派生类对象名或引用名 . 成员名” 、 “派生类指针->成员名” 来访问。
2、此时则只能且必须用类名进行限定。
多继承时的二义性和冗余问题：

#include <iostream>
using namespace std;
class Base0{
	public:
		int var0;
		void fun(){cout<<"Base0"<<endl;}
};

class Base1:public Base0{
	public:
		int var1;
};

class Base2:public Base0{
	public:
		int var2;
};

class Derived:public Base1,public Base2{
	public:
		int var;
		void fun(){cout<<"Derived"<<endl;}
};
int main()
{	
	Derived d;
	d.Base1::var0=1;
	d.Base1::fun();
	d.Base2::var0=2;
	d.Base2::fun();
	d.fun();       //访问Derived的fun函数
	return 0;
}

注： 此时可以看出对象的存储时冗余的，这样会带来空间的浪费，同时会造成不一致性使使用时会发生混淆，故这种情况应该在写程序时避免。

虚基类

需要解决的问题：
当派生类从多个基类派生，而这些基类又有共同基类，则在访问此共同基类中的成员时，将产生冗余，并有可能因为冗余带来不一致性。
虚基类声明：
以virtual说明基类继承方式
例：class B1：virtual public B
作用：
1、主要用来解决多继承时可能发生的对同一基类继承多次产生的二义性问题
2、为最远的派生类提供唯一的基类成员，而不重复产生多次复制
注意：
在第一次继承时就要将共同基类设置成虚基类

#include <iostream>
using namespace std;
class Base0{
	public:
		int var0;
		void fun0(){cout<<"Base0"<<endl;}
};

class Base1:virtual public Base0{         //虚继承
	public:
		int var1;
};

class Base2:virtual public Base0{         //虚继承
	public:
		int var2;
};

class Derived:public Base1,public Base2{
	public:
		int var;
		void fun(){cout<<"Derived"<<endl;}
};
int main()
{	
	Derived d;
	d.var0=2;         //直接访问虚基类的数据成员
	d.fun0();        //直接访问虚基类的函数成员
	return 0;
}

此时Derived中只包含一个var0和fun0()，则可以用Derived对象直接调用var0且不存在二义性和冗余问题。

虚基类及其派生类构造函数：
1、建立对象时所指定的类称为最远派生类。
2、虚基类的成员是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。
3、在整个继承结构中，直接或间接继承虚基类的所有派生类，都必须在构造函数的成员初始化表中为虚基类的构造函数列出参数。如果未列出，则表示调用该虚基类的默认构造函数。
4、在建立对象时，只有最远派生类的构造函数调用虚基类的构造函数，其他类对虚基类的构造函数的调用被忽略。

#include <iostream>
using namespace std;
class Base0{
	public:
		int var0;
		Base0(int var):var0(var){}
		void fun0(){cout<<"Base0"<<endl;}
};

class Base1:virtual public Base0{
	public:
		Base1(int var):Base0(var){}
		//直接或间接继承虚基类的所有派生类，都必须在构造函数的成员初始化表中为虚基类的构造函数列出参数
		int var1;
};

class Base2:virtual public Base0{
	public:
		Base2(int var):Base0(var){}
		int var2;
};

class Derived:public Base1,public Base2{
	public:
		int var;
		Derived(int var):Base0(var),Base1(var),Base2(var){}
		//若不是虚继承，则第一个Base0(var)不用写，因为只需要给它的直接基类的构造函数传递参数 
		void fun(){cout<<"Derived"<<endl;}
};
int main()
{	
	Derived d(1);
	//在执行时，只会给虚基类构造函数传递一次参数，而Base1和Base2中给虚基类传递参数的将会被忽略 
	d.var0=2;
	d.fun0();
	return 0;
}