浅谈C++的继承与派生

---

继承与派生

概述

1. 继承与派生概述：

• 继承与派生是同一过程从不同的角度看

  1. 保持已有类的特性而构造新类的过程称为继承。
  2. 在已有类的基础上新增自己的特性而产生新类的过程称为派生。扩展的过程

• 被继承的已有类称为基类 (或父类 )。

• 派生出的新类称为派生类(或子类)。

• 直接参与派生出某类的基类称为直接基类。

• 基类的基类甚至更高层的基类称为间接基类。

• 继承与派生的目的：

  1. 继承： 实现设计与代码的重用
  2. 派生：对原有的类进行改造升级，用来解决新的问题。

• C++支持多重继承。

2. 单继承继承的语法：

class 派生类名：继承方式 基类名
{
	成员声明;
}

例：

class Son:public Father
{
	public:
	Son();
	~Son();	
}

3. 多继承的语法：

class 派生类：继承方式1 基类名1，继承方式2 基类名2……
{
	成员声明;
}

例：

class Son:public A,private B
{
public:
	Son();
	~Son();
}

4. 派生类的构成：

1. 吸收自基类的成员
   1. 在默认情况下，不继承基类的构造函数和析构函数，其他的都默认继承。
   2. C++11中可以使用using语句继承基类的构造函数。
2. 改造的基类的成员
   1. 和基类同名的成员。
3. 新定义的自己的成员

5. 继承关系和复合关系：

• 继承：“是”的关系，逻辑上要求：派生类的对象也是基类的对象。
• 复合：“有”的关系，逻辑上要求：一个对象是另外一个对象的固有属性或组成部分。
• 继承关系和复合关系的选择：
  1. 如果一个类的对象是另外一个类的对象，就可以使用继承。如：人类 → 男人
  2. 如果一个类可以另外一个类的成员，就使用复合。如：点 ∈ 圆 （根据需要合理使用友元）
  3. 一个类的成员是另外一个类的指针。

继承方式

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

• 三种继承方式：
  （1） 公有继承（public）：（最常用）

  1. 继承的访问控制：
     1. 基类的public和protected成员：访问属性在派生类中保持不变;
     2. 基类的private成员：不可直接访问。（通过公有访问接口）
  2. 访问权限：
     1. 派生类中的成员函数：在派生类中可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。（在类外不能访问继承的protected成员。）
     2. 通过派生类的对象：只能访问public成员。

  （2）私有继承(private)：作用：起将基类的所有公有接口都封闭掉的作用。

  3. 继承的访问控制：
     1. 基类的public和protected成员：都以private的身份出现在派生类中。
     2. 基类的private成员：不可直接访问。
  4. 访问权限：
     1. 派生类中的成员函数：可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员;
     2. 通过派生类的对象：不能直接访问从基类继承的任何成员。可以在派生类中定义一个访问基类成员的接口。

  （3） 保护继承

  5. 继承的访问控制：
     1. 基类的public和protected成员：都以protected的身份出现在派生类中。
     2. 基类的private成员：不可直接访问。
  6. 访问权限：
     1. 派生类中的成员函数：可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员;
     2. 通过派生类的对象：不能直接访问从基类继承的任何成员。可以在派生类中定义一个访问基类成员的接口。
  7. protected成员的特点与应用：
     1. 对建立其所在类对象的模块来说，它与private成员的性质相同。
     2. 对于其派生类来说 ，它与public成员的性质相同。
     3. 既实现了数据隐藏，又方便继承，实现代码重用。

#include<iostream>
using namespace std;
class A
{
protected:
	int x;

};
class B :protected A
{
public:
	void setX(int x)
	{
		this->x = x;
	}
	int getX()
	{
		return x;
	}
};
int main()
{
	//A a;
	//a.x = 20;//错误
	B b;
	b.setX(10);
	cout << b.getX() << endl;
	return 0;
}

• 多继承时，每个类的继承方式不不同。

基类与派生类的类型转换：

• 类型转换
  （1）公有派生类对象可以被当作基类的对象使用 ，反之则不可。（因为派生类已经对基类做了扩展）

  1. 派生类的对象可以隐含转换为基类对象 ;
  2. 派生类的对象可以初始化基类的引用 ;
  3. 派生类的指针可以隐含转换为基类的指针。

  （2）通过基类对象名、指针只能使用从基类继承的成员。

#include<iostream>
using namespace std;
class A
{
public:
	void display()
	{
		cout << "I am A" << endl;
	}

};
class B :public A
{
public:
		void display()
	{
		cout << "I am B" << endl;
	}

};
class C :public B
{
public:
	void display()
	{
		cout << "I am C" << endl;
	}
};
void fun(A *p)
{
	p->display();
}
int main()
{
	A a;
	B b;
	C c;

	fun(&a);
	fun(&b);
	fun(&c);
	return 0;
}

输出：
I am A
I am A
I am A

构造与析构

默认情况下：

• 基类的构造函数不被继承。
• 派生类需要定义自己的构造函数，还需要向基类的构造函数传递参数。
• 可以使用 using 语句继承基类的构造函数，但只适用于派生类很少增加基类的成员。不能初始化自己创建的新成员。
  1. using语法：using B::B;

若不继承基类的构造函数：

• 派生类新增成员：派生类定义构造函数初始化
• 继承来的成员：自动调用基类构造函数进行初始化;
• 派生类的构造函数需要给基类的构造函数传递参数。

单继承：

• 单继承时构造函数语法：

派生类名::派生类名(基类所需参数，本类成员所需的参数):基类名(参数表)，
本类成员初始化表
{
	//其他初始化
}

#include<iostream>
using namespace std;
class A
{
private:
	int a;
public :
	A();
	A(int a);
	~A();
	void display() const
	{
		cout<< a << endl;
	}

};
A::A()
{
	this->a = 0;
	cout << "A类无参构造函数" << endl;
}
A::A(int a)
{
	this->a = a;
	cout << "A类有参数的构造函数" << endl;
}
A::~A() {
	cout << "A类析构函数" << endl;
}
class B :public A
{
private:
	int b;
public:
	B();
	B(int i,int j);
	~B();
	void display() const
	{
		cout << b << endl;
	}

};
B::B()
{
	this->b = 0;
	cout << "B类无参构造函数" << endl;
}
B::B(int i, int j):A(i),b(j)
{
	cout << "B类有参数构造函数" << endl;
}
B::~B()
{
	cout << "B类析构函数" << endl;
}

int main()
{
	B b(23,45);
	b.display();

	return 0;
}

多继承

多继承时构造函数的定义语法：

派生类名::派生类名(基类所需参数，本类成员所需的参数):
基类名1(基类1初始化参数表)，
基类名2(基类2初始化参数表)，
……
本类成员初始化表
{
	//其他初始化
}

当基类有默认构造函数时

• 派生类构造函数可以不向基类构造函数传递参数。
• 构造派生类的对象时，基类的默认构造函数将被调用。
• 如需执行基类中带参数的构造函数，派生类构造函数应为基类构造函数提供参数。

构造函数的调用次序：（依次执行如下）

1. 第一步：调用基类构造函数。
   顺序按照它们被继承时声明的顺序 (从左向右)。
2. 第二步：对初始化列表中的成员进行初始化。
   顺序按照它们在类中定义的顺序。
   对象成员初始化时自动调用其所属类的构造函数。由初始化列表提供参数。
3. 第三步：执行派生类的构造函数体中的内容。

派生类的析构函数
　　
　　析构函数不被继承，析构函数的声明方法和普通类的析构函数的声明方法相同，不需要显示的调用基类的析构函数，系统会自动的调用
先执行派生类的的析构函数，在调用基类的析构函数。

访问继承的成员

当派生类与基类中有相同成员时:

1. 若末特别限定，则通过派生类对象使用的是派生类中的同名成员。
2. 如要通过派生类对象访问基类中被隐藏的同名成员,应使用基类名和作用，操作符( :: )来限定。
3. 例：子类对象名.基类名::变量名或函数名

二义性问题

1. 如果从不同基类继承了同名成员，但是在派生类中没有定义同名成员，“派生类对象名或引用名 .成员名，派生类指针-> 成员名”访问成员存在二义性问题
2. 解决方式：用类名限定。
3. 例：子类对象名.基类名::成员或方法名

#include<iostream>
using namespace std;

class A
{
public:
	void dispaly()
	{
		cout << "A" << endl;
	}


};
class B
{
public:
	void dispaly()
	{
		cout << "B" << endl;
	}
};
class sup:public A,public B
{
public:
	void abc()
	{
		cout << "suo" << endl;
	}

};
int main()
{
	sup s;
	//s.dispaly();//报错，有二义性
	s.A::dispaly();//使用类名限定
	s.B::dispaly();


	return 0;
}

虚基类

需要解决的问题：（菱形继承）
当派生类从多个基类派生，而这些基类又有共同基类，则在访问此共同基类中的成员时，将产生冗余，并有可能因冗余带来不一致性。

虚基类声明

1. 以virtual说明基类继承方式
   例: class B1:virtual public B
2. 作用
   主要用来解决多继承时可能发生的对同一基类继承多次而产生的二义性问题。
   为最远的派生类提供唯一的基类成员，而不重复产生多次复制。
3. 注意:
   在第一级继承时就要将共同基类设计为虚基类。即：在第一级继承时就要使用virtual关键字继承公共基类。

虚基类及其派生类构造函数

建立对象时所指定的类称为：最远派生类。

虚基类的成员是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。

在整个继承结构中，直接或间接继承虚基类的所有派生类 ,都必须在构造函数的成员初始化表中为虚基类的构造函数列出参数。如果未列出，则表示调用该虚基类的默认构造函数。但是会被忽略。

在建立对象时，只有最远派生类的构造函数调用虚基类的构造函数，其他类对虚基类构造函数的调用被忽略。

#include <iostream>
using namespace std;
class Base0{
public:
	Base0(int var) : var0(var) { }
	int var0;
	void fun0() 
	{
		cout << "Member of 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:
	Derived(int var) : Base0(var), Base1(var), Base2(var)//需要为Base0提供参数。
	{}
	int var;
	void fun()
	{
		cout << "Member of Derived" << endl;
	}
};
int main() { //程序主函数
	Derived d(1);//Base0的构造函数只执行一次
	d.var0 = 2; //直接访问虚基类的数据成员
	d.fun0(); //直接访问虚基类的函数成员
	return 0;
}

到达胜利之前，无法回头

博客首页