C++继承的简单认识

C++继承的简单认识

面向对象程序设计中最重要的一个概念是继承。

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用变得更加容易。这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，你不需要重新编写新的数据成员和成员函数，只需要指定新建的类继承继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a的关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

代码如下：

//基类
class animal
{
	//eat()函数
	//sleep()函数
};

//派生类
class dog :public animal
{
	//bark()函数
};

派生类的定义格式

派生类有单继承和多继承，他们的派生类的定义格式稍有不同。

【1】单继承
单继承定义格式如下

class 派生类名：继承方式（public/private/protected） 基类名
{
	派生类新定义成员；
}；

其中，“派生类名”是新定义的一个类的名字，他是从“基类名”中诞生。并且按指定的“继承方式”派生。继承方式有以下3种。
·public：表示公有基类
·private：表示私有基类（默认的继承方式）
·protected：表示保护基类
例如，以下代码从类A派生出类B，这里是单继承方式。

class A
{
	//类的成员
}
class B:public A
{
	//类B新添加的成员
}

【2】多继承
多继承的定义格式如下：

class 派生类名：继承方式1 基类名1，继承方式2 基类名2，……
{
	派生类新定义成员；
}

从定义格式上来看，多继承与单继承的区别主要是多继承的基类多于一个。
例如，从以下代码段从类A和类B派生出类C，这里是多继承方式：

class A
{
	//类的成员
}
class B 
{
	//类的成员
}
class C : public A,private B
{
	//类C新添加的成员
}

派生类的生存过程

在c++程序设计中，一般先建立基类，然后建立派生类，通过派生类创建对象进行实际问题的处理。
派生新类一般经历3个阶段：吸引基类成员、改造基类成员、添加新的成员。下面介绍这几个阶段的任务。

1·吸引基类成员

在c++类的继承中，首先是将基类的成员全部接收，这样，派生类实际上就包含了它的所有基类中除构造函数和析构函数之外的全部成员。

2·改造基类成员

对基类成员的改造分为两个方面：

·基类成员的访问控制问题，主要依靠派生类定义时的继承方式来控制

·对基类数据成员或成员函数的覆盖，就是在派生类中定义一个和基类数据成员或成员函数同名的成员，由于作用域不同，于是发生同名覆盖，基类中的成员就被替换成派生类中的同名成员。注意对于派生类中与基类同名的成员函数，它的参数表也必须和基类同名成员函数的一样，否则是重载，不能发生同名覆盖。

3·添加新的成员

派生类新成员的加入是继承与派生机制的核心，是保证派生类在功能上有所发展的关键。可以根据实际情况的需要，给派生类添加适当的数据成员和成员函数，来实现必要的新增功能。同时在派生的过程中，基类的构造函数和析构函数是不能被继承下来的，一些特别的初始化和扫尾工作，也需要重新加入新的构造函数和析构函数。

类成员的访问权限

若有一个类A，对于它的成员，无论具有何种访问权限，都可以被该类的所有成员函数访问，也就是说，他对于类A自身的任何成员都具有访问性
若有一个类A和一个派生类B，基类A的私有成员不能继承下来，但其public和protect成员可以被继承，因此派生类B可以访问基类A中的public成员和protect成员，但不能访问基类中的private成员。
若有一个类A和一个关联类B，只能通过A的对象访问类A的公有成员，不能访问私有和保护成员，这一点和类A的一般对象具有访问控制规则是相同的。

继承方式

基类的成员可以有public、protected、private等三种访问权限，基类的自身成员可以对基类中任意一个其他成员进行访问，但是通过基类的对象就只能访问该类的公有成员。
类的继承方式有public、protected、private等三种。不同的继承方式会导致原来具有不同访问属性的基类成员在派生类中的访问属性也不相同。这里说的访问主要来自两个方面：一是派生类中的新增成员对从基类继承来的成员的访问；而是派生类外部通过派生类的对象对从基类继承来的成员的访问。接下来我们将说明3中继承方式。

1·公有继承

当类的继承方式为公有继承时，，基类public和protected成员的访问属性在派生类中保持原来的访问属性不变，而基类private成员在派生类中不可访问，即基类的public和protect成员分别作为派生类public和protected成员，派生类的其他成员可以直接访问他们。
【例题】

#include<iostream>
using namespace std;
class A					//基类
{
public:int x;
};
class B :public A		//派生类
{
private:
	int y;
protected:
	int z;
public:
	int m;
	void setvalue(int a, int b, int c, int d)
	{
		x = a;			//在B类中x仍为公有变量，可以访问
		y = b;			//在B类中y为protected访问属性，可以访问
		z = c;			//在B类中z为public访问属性，可以访问
		m = d;
	}
	void display()
	{
		cout << "y=" << y << endl;
		cout << "z=" << z << endl;
	}
};
int main()
{
	B obj;
	obj.setvalue(1, 2, 3, 4);
	cout << "x=" << obj.x << endl;
	obj.display();
	cout << "m=" << obj.m << endl;
	//cout<<"y="<<obj.y<<endl;		y为private权限，不能通过对象访问
	//cout<<"z="<<obj.z<<endl;		z为protected权限，不能通过对象访问
	//obj.m=4;						m为public权限，可以通过对象访问
	return 0;
}

解答：上述程序中，基类A中声明了一个数据成员下，它为public访问权限。类B是从类A派生的（属单继承的情况），其继承方式为public，因此在派生类B中，实际所拥有的成员为：
x具有public权限，
y具有private权限
z具有protected权限，
m具有public权限。
·

2·私有继承

当类的继承方式为私有继承时，基类public和protect成员都以private权限出现在派生类中，而基类private成员在派生类中不可访问，即基类的public和protected成员被继承后作为派生类的私有成员，派生类的其他成员可以直接访问他们，但是在类的外部通过派生类的对象无法访问他们。无论是派生类的成员还是派生类的对象都无法访问从基类继承的private成员
经过私有继承之后，所有基类的成员都成为派生类的私有成员，如果进一步派生的话，基类的成员就无法在新的派生类中被访问。因此，私有继承之后，基类的成员再也无法在以后的派生类中发挥作用，实际上相当于终止了基类功能的继续派生。
【例题】

#include<iostream>
using namespace std;
class A
{
private:
	int x;
public:
	void setx(int i)
	{
		x = i;
	}
	void disp()
	{
		cout << "x=" << x << endl;
	}
};
class B :private A
{
private:
	int y;
protected:
	int z;
public:
	int m;
	void setvalue(int a, int b, int c, int d)
	{
		setx(a);
		y = b;
		z = c;
		m = d;
	}
	void display()
	{
		//cout<<"x="<<x<<endl    在B类中x不可以被访问，应通过A类的公有成员函数disp（）实现输出
		disp();
		cout << "y=" << y << endl;
		cout << "z=" << z << endl;
	}
};
int main()
{
	B jian;
	jian.setvalue(1, 2, 3, 4);
	jian.display();
	//cout<<"y="<<jian.y<<endl;			y为private权限，不能通过对象访问
	//cout<<"z="<<jian.z<<endl;			z为protected权限，不能通过对象访问
	jian.m = 4;							//m为public权限。可以通过对象访问
	cout << "m=" << jian.m << endl;		//m为public权限。可以通过对象访问
	return 0;
}

解答：上述的程序中，基类A中声明了一个数据成员x，他是private访问权限。类B是从类A中派生的（属单继承的情况），其继承方式为private，因此在派生类B中，不存在数据成员x，类B中只存在本身声明的数据成员：y具有private权限、z具有protected权限，m具有public权限。为此在类A中设计了两个公有成员函数实现对x的赋值和输出，在类B中调用这两个公有成员函数实现对类A中x数据成员的操作。

3· 保护继承

当类的继承方式为保护继承时，基类public和protected成员都以protected权限出现在派生类中，而基类private成员不可访问，即基类的public和protected成员被继承以后作为派生类的保护成员，这样，派生类的其他成员就可以直接访问他们，但在类外部通过通过派生类的对象无法访问。private都不可以访问。
比较私有继承和保护继承可以看出，实际上在直接派生类中，所有成员的访问属性都是完全相同的。但是，如果派生类作为新的基类，继续派生时，两者的差别就出现了。
假设B类以私有化方式继承了A类后，B类又派生出C类，那么C类的成员和对象都不能访问间接从A类继承而来的成员。如果B类是以保护方式继承了A类，那么A类中的公有和保护成员在B类中都是保护成员。B类在派生出C类后，A类中的公有和保护成员被C间接继承后，有可能时保护的或者是私有的（视从B到C的派生方式不同而异）。因而，C类成员有可能可以访问间接从A类中继承来的成员。

#include<iostream>
using namespace std;
class A
{
protected:
	int x;
};
class B :protected A
{
private:
	int y;
protected:
	int z;
public:
	int m;
	void setvalue(int a, int b, int c, int d)
	{
		x = a;			//在B类中x作为protected数据成员
		y = b;			//在B类中y为private访问，可以访问
		z = c;			//在B类中z为protected访问属性，可以访问
		m = d;
	}
	void display()
	{
		cout << "x=" << x << endl;
		cout << "y=" << y << endl;
		cout << "z=" << z << endl;
	}
};
int main()
{
	B jian;
	jian.setvalue(1, 2, 3, 4);
	jian.display();
	//cout<<"y="<<y<<endl;			y为private权限，不能通过对象访问
	//cout<<"z="<<z<<endl;			z为protected权限，不能通过对象访问
	jian.m = 4;
	cout << "m=" << jian.m << endl;	//m为public权限，可以通过对象访问
}

【例题】

#include<iostream>
using namespace std;
class A
{
private:
	int x;
protected:
	int y;
public:
	int z;
	void setx(int i)
	{
		x = i;
	}
	int getx()
	{
		return x;
	}
};
class B :public A
{
private:
	int m;
protected:
	int n;
public:
	int p;
	void setvalue(int a, int b, int c, int d)
	{
		setx(a);			//在B类中x不可访问
		y = b;				//在B类中y为protected访问权限，可以访问
		m = c;		
		n = d;
	}
	void display()
	{
		cout << "x=" << getx() << endl;
		//cout<<"x="<<x<<endl;		//x在派生类中不可访问
		cout << "y=" << y << endl;	//在类B中y为protected访问权限
		//cout<<"z="<<z<<endl;		//在类B中z为public访问权限，可以访问
		cout << "m=" << m << endl;
		cout << "n=" << n << endl;
	}
};
int main()
{
	B jian;
	jian.z = 10;
	jian.p = 20;
	jian.setvalue(1, 2, 3, 4);
	jian.display();
	cout << "z=" << jian.z << endl;	//z为public访问权限，可以通过对象访问
	cout << "p=" << jian.p << endl;	//p为public访问权限，可以通过对象访问
	return 0;
}

解答：上述程序中，基类A声明了3个数据成员x，y，z，他们分别为private、protected和public访问权限，另外定义了setx和getx两个public成员函数。类B是从类A中派生的（单继承），其继承方式为protected，因此在派生类B中，实际所拥有的成员就是从基类里继承过来的成员与派生类新定义成员的总和。继承方式为公有继承，这时，基类A的所有成员在派生类中的访问权限都保持原样，派生类B的成员函数及对象无法访问基类的私有数据，但是同样可以访问到基类的公有成员。
·
·

继承函数中构造函数的使用

因为基类的成员函数可以被继承，可以通过派生类的对象访问，但这仅仅指的是普通的成员函数。而类的构造函数不能被继承。解决这个问题方法就是：在派生类的构造函数中调用基类的构造函数。

【例】

这里括号里的数据成员就是在派生类中定义的数据成员。而且此时基类里赋值了之后，派生类里的构造函数就不用再赋值参数给他了。

·
·
文章来源于书本文章资料，仅用于个人学习。