c++基础知识day6

1.多继承的概念

多继承：一个类允许有多个直接基类

//多继承语法：class A:访问控制符 基类1，访问控制符 基类2，。。。。

class Child: public Parent1, public Parent2

{

public:
 // 1、如果基类 没有无参构造，需要在对象 初始化列表中显示调用基类的构造函数
 // 2、基类的构造顺序和在对象列表中 调用顺序无关，和在继承时候 继承顺序有关
 Child():Parent1(1,2),Parent2(3,4)
 {
  c = 10;
  cout << "Child 无参构造" << endl;
 }

 void showC()
 {
  printf ("c = %d\n",c);
 }
private:
 int c;
};

// 基类指针可以指向派生类

Child c;

// 基类指针指向派生类，基类指定不一定和派生类指针重合
 // 会根据在派生类中的排布做相应的偏移
 // 基类指针操作派生类对象在多继承中也是可以使用

Child *pc   = &c;
 Parent1 *p1 = &c;
 Parent2 *p2 = &c;

2.多继承的二义性

class Parent1
{
public:
 int a;
 int b;
};

class Parent2
{
public:
 int b;
 int c;
};

class Child:public Parent1, public Parent2
{
public:
 int e;
};

int main()
{
 Child c;
 c.a = 1;
 // 基类中有 相同成员，在调用的时候会产生二义性
 // 解决：指明 具体的基类
  c.Parent1::b = 2;
  c.Parent2::b = 5;
 c.c = 3;
 c.e = 4;

 return 0;
}

3.多继承的二义性2

#include <iostream>
using namespace std;

class Parent
{
public:
 Parent()
 {
  cout << "P   构造函数被调用" << endl;
 }
public:
 int a;
};

class Parent1 :public Parent
{
public:
 Parent1()
 {
  cout << "P1   构造函数被调用" << endl;
 }
public:
 int b;
};

class Parent2: public Parent
{
public:
 Parent2()
 {
  cout << "P2   构造函数被调用" << endl;
 }
public:
 int c;
};

class Child:public Parent1, public Parent2
{
public:
 Child()
 {
  cout << "C   构造函数被调用" << endl;
 }
public:
 int d;
};

int main()
{
 Child c;

//派生的多继承基类都有共同的基类时需要使用域解析符::
 c.Parent1::a = 1;
  c.Parent2::a = 2;

 return 0;
}

4.虚继承

// 在继承时添加一个关键字:  virtual  ====> 虚继承

class Parent

int a;

class Parent1 :virtual public Parent

int b;

class Parent2:virtual public Parent

int c;

class Child:public Parent1, public Parent2

int d;

Child c;
 c.a = 1;
 c.b = 2;
 c.c = 3;
 c.d = 4;

1. 任何虚基类的构造函数按照它们被继承的顺序调用
2. 任何非虚基类的构造函数按照它们被继承的顺序调用
3. 任何成员对象的构造函数按照它们声明的顺序调用
4. 类自己的苟构造函数

5.多态的概念

// 基类
class Animal
{
public:
	void eat()
	{
		cout << "动物吃饭" << endl;
	}

	// 虚函数
	virtual void sleep()
	{
		cout << "动物睡觉" << endl;
	}
};

class Cat :public Animal
{
public:
	// 函数 重定义
	void eat()
	{
		cout << "猫 吃  鱼" << endl;
	}

	// 虚函数 的重定义  =====>  函数重写
	void sleep()
	{
		cout << "猫 趴着睡觉" << endl;
	}
};

class Fish :public Animal
{
public:
	// 函数 重定义
	void eat()
	{
		cout << "鱼 吃 虾" << endl;
	}

	// 函数 重定义
	void sleep()
	{
		cout << "鱼 睁着眼睡觉" << endl;
	}
};

// 基类指针
// 期望做的事情：同样的调用语句
// 1、当基类指针指向基类对象的时候，调用基类自己的成员函数
// 2、当基类指针指向派生类对象的时候，调用派生类的同名成员函数

// =====> 多态：一种调用语句有多种不同的表现形态
// =====> 实现：通过 虚函数 来实现   ---> 在函数声明前加 virtua 关键字，该函数就变为虚函数

// 预处理、编译、汇编、链接
void func(Animal *pa)
{
	// 指针的行为受限于指针的类型
	// pa 是 Animal 类型，所以只能执行 Animal 内部的方法

	// 1、判断 pa 的类型        -----> Animal 类型
	// 2、判断 eat() 函数类型   -----> 普通函数
	// 3、结果：因为是普通函数，则按照指针类型调用 -----> Animal::eat()
	// ==========>  在编译期间就已经知道如何处理、如何运行  ------> 静态联编   早期绑定
	pa->eat();

	// 1、判断 pa 的类型        -----> Animal 类型
	// 2、判断 sleep() 函数类型 -----> 是虚函数
	// 3、结果：因为是虚函数，所以不知道调用谁的函数 
	// -------> 通过某种机制，找到 最终需要调用的函数（和传过来的对象有关）
	// ==========>  在编译期间无法知道具体如何处理、在运行的时候根据传入的对象才能确定具体
	// 调用          ------> 动态联编   迟绑定
	pa->sleep();
}

// 多态实现条件：
// 1、要有继承
// 2、要有虚函数
// 3、要有基类指针指向派生类对象

int main()
{
	Animal a;
	Cat    c;
	Fish   f;
	func(&a);

	cout << "------------------------" << endl;
	func(&c);

	cout << "------------------------" << endl;
	func(&f);

	return 0;
}

int main1()
{
	Animal a;
	Cat    c;
	Fish   f;
	a.eat();
	a.sleep();
	
	cout << "------------------------" << endl;
	c.eat();
	c.sleep();

	cout << "------------------------" << endl;
	f.eat();
	f.sleep();

    return 0;
}