QAtime1H_2021_2_15——主题C++

今天药忘吃喽~ 2022-10-29 13:22 56阅读 0赞

**目录**

1.今天解决问题？

2.HelloWorld？

3.内存四区域

4.new 和 delete

5.引用做函数参数

6.函数默认参数

7.函数占位参数

8.函数重载

9.C++面向对象的三大特性？

10.封装练习？

11将类拆分为头文件和其它c++文件？

12对象:构造函数和析构函数?

13有参构造和无参构造

14普通构造和拷贝构造

15深拷贝与浅拷贝

16构造函数初始化列表

17静态成员

18静态成员函数

19this指针

20空指针访问成员函数

21const修饰成员函数

22友元

23加号运算符重载

24左移输出运算符重载

25递增运算符重载

26赋值运算符重载

27关系运算符重载

28函数调用运算符重载，仿函数

30为什么要有继承？

31继承有几种？

32父子同名成员，同名成员函数，同名静态成员

33vbptr虚基类指针解决菱形继承问题？

--------------------

## ##

### 1.今天解决问题？ ###

<table> 
 <thead> 
  <tr> 
   <th>阶段</th> 
   <th>内容</th> 
   <th>目标</th> 
   <th>案例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>第一阶段</td> 
   <td>C++基础语法入门</td> 
   <td>对C++有初步了解，能够有基础编程能力</td> 
   <td>通讯录管理系统</td> 
  </tr> 
  <tr> 
   <td>第二阶段</td> 
   <td>C++核心编程</td> 
   <td>介绍C++面向对象编程，为大型项目做铺垫</td> 
   <td>职工管理系统</td> 
  </tr> 
  <tr> 
   <td>第三阶段</td> 
   <td>C++提高编程</td> 
   <td>介绍C++泛型编程思想，以及STL的基本使用</td> 
   <td>演讲比赛系统</td> 
  </tr> 
 </tbody> 
</table>

综合大案例：机房预约系统

### 2.HelloWorld？ ###

#include<iostream>
    using namespace std;
    int main()
    {
    	cout << "Hello World" << endl;
            system("pause");
    	return 0;
    }

### 3.内存四区域 ###

*  代码区：存放函数体的二进制**代码**，由操作系统进行管理的
 *  全局区：存放**全局变量和静态变量**以及常量
 *  栈区：由编译器自动分配释放, 存放**函数的参数值,局部变量**等
 *  堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收， 存放**动态开辟的空间**

### 4.new 和 delete ###

int \*a=new int(120);  
申请一个整型变量空间，赋初值为120，并定义一个整型指针a指向该地址空间

int \*a=new int\[120\];  
申请120个整型变量空间，没有赋初值，并定义一个整型指针a指向该地址空间开始处

#include<iostream>
    using namespace std;
    int main() {
    	int* p = new int(10);
    	cout << *p << endl;
    	delete p;
    	system("pause");
    	return 0;
    }

#include<iostream>
    using namespace std;
    int main() {
    
    	int* arr = new int[10];
    
    	for (int i = 0; i < 10; i++)
    	{
    		arr[i] = i + 100;
    	}
    
    	for (int i = 0; i < 10; i++)
    	{
    		cout << arr[i] << endl;
    	}
    	//释放数组 delete 后加 []
    	delete[] arr;
    
    	system("pause");
    
    	return 0;
    }

### 5.引用做函数参数 ###

传入和值传递一样

编写函数加上引用时，就是对本身进行操作而非临时拷贝

#include<iostream>
    using namespace std;
    void Swap(int& a, int& b)
    {
    	int tmp = a;
    	a = b;
    	b = tmp;
    }
    
    int main() {
    	//引用做函数参数
    	int a;
    	cin >> a;
    	int b;
    	cin >> b;
    	Swap(a, b);
    	cout << a<<" "<<b << endl;
    	system("pause");
    	return 0;
    }

### 6.函数默认参数 ###

C++函数的实现传入值可以有默认值

#include<iostream>
    using namespace std;
    int func(int a = 10, int b = 20)
    {
    	return a + b;
    }
    int main() {
    	int c = func(20);
    	cout << c << endl;
    	system("pause");
    	return 0;
    }
    //40

### 7.函数占位参数 ###

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

#include<iostream>
    using namespace std;
    void func(int a, int)
    {
    	cout<<"HAHAHA"<<endl;
    }
    int main() {
    	func(20,20);
    	system("pause");
    	return 0;
    }
    //HAHAHA

### 8.函数重载 ###

**作用：** 函数名可以相同，提高复用性

**函数重载满足条件：**

*  同一个作用域下
 *  函数名称相同
 *  函数参数**类型不同** 或者 **个数不同** 或者 **顺序不同**

*  引用作为重载条件，传数字const，传变量无const
 *  函数重载不能碰到函数默认参数

### 9.C++面向对象的三大特性？ ###

封装：class类

继承：父与子

多态：？

### 10.封装练习？ ###

**练习案例1：设计立方体类**

设计立方体类(Cube)

求出立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70][]

#include<iostream>
    using namespace std;
    class Cube
    {
    public:
    	void SetLength(int l)
    	{
    		m_L=l;
    	}
    	int GetLength()
    	{
    		return m_L;
    	}
    	void SetHigh(int h)
    	{
    		m_H = h;
    	}
    	int GetHigh()
    	{
    		return m_H;
    	}
    	void SetWidth(int w)
    	{
    		m_W = w;
    	}
    	int GetWidth()
    	{
    		return m_W;
    	}
    	int GetS()
    	{
    		return (m_L * m_W + m_L * m_H + m_W * m_H)*2;
    	}
    	int GetV()
    	{
    		return m_L * m_W * m_H;
    	}
    
    private:
    	int m_H;
    	int m_L;
    	int m_W;
    };
    bool IsSame(Cube x, Cube y)
    {
    	if ((x.GetHigh() == y.GetHigh()) && (x.GetWidth() == y.GetWidth()) && (x.GetLength() == y.GetLength()))
    		return true;
    	else
    		return false;
    }
    
    int main() {
    	Cube a, b;
    	a.SetHigh(10);
    	a.SetLength(10);
    	a.SetWidth(10);
    	b.SetHigh(10);
    	b.SetLength(20);
    	b.SetWidth(10);
    	cout << "S_a:" << a.GetS() << endl;
    	cout << "S_b:" << b.GetS() << endl;
    	cout << "V_a:" << a.GetV() << endl;
    	cout << "V_b:" << b.GetV() << endl;
    	if (IsSame(a, b))
    	{
    		cout << "same" << endl;
    	}
    	else
    	{
    		cout << "not same" << endl;
    	}
    	system("pause");
    	return 0;
    }
    /*
    S_a:600
    S_b:1000
    V_a:1000
    V_b:2000
    not same
    请按任意键继续. . .
    */

### 11**将类拆分为头文件和其它c++文件？** ###

Cube.h：包含全部头文件，只留声名

#pragma once
    #include<iostream>
    using namespace std;
    class Cube
    {
    public:
    	void SetLength(int l);
    	int GetLength();
    	void SetHigh(int h);
    	int GetHigh();
    	void SetWidth(int w);
    	int GetWidth();
    	int GetS();
    	int GetV();
    private:
    	int m_H;
    	int m_L;
    	int m_W;
    };

Cube.cpp：头文件只有\#include"Cube"，只留函数实现，并在函数返回值和函数名前加上函数的作用域Cube::

#include"Cube.h"
    	void Cube::SetLength(int l)
    	{
    		m_L = l;
    	}
    	int Cube::GetLength()
    	{
    		return m_L;
    	}
    	void Cube::SetHigh(int h)
    	{
    		m_H = h;
    	}
    	int Cube::GetHigh()
    	{
    		return m_H;
    	}
    	void Cube::SetWidth(int w)
    	{
    		m_W = w;
    	}
    	int Cube::GetWidth()
    	{
    		return m_W;
    	}
    	int Cube::GetS()
    	{
    		return (m_L * m_W + m_L * m_H + m_W * m_H) * 2;
    	}
    	int Cube::GetV()
    	{
    		return m_L * m_W * m_H;
    	}

test.cpp：头文件包含所有的.h文件，里面装着测试功能

#include<iostream>
    #include"Cube.h"
    using namespace std;
    
    bool IsSame(Cube x, Cube y)
    {
    	if ((x.GetHigh() == y.GetHigh()) && (x.GetWidth() == y.GetWidth()) && (x.GetLength() == y.GetLength()))
    		return true;
    	else
    		return false;
    }
    
    int main() {
    	Cube a, b;
    	a.SetHigh(10);
    	a.SetLength(10);
    	a.SetWidth(10);
    	b.SetHigh(10);
    	b.SetLength(20);
    	b.SetWidth(10);
    	cout << "S_a:" << a.GetS() << endl;
    	cout << "S_b:" << b.GetS() << endl;
    	cout << "V_a:" << a.GetV() << endl;
    	cout << "V_b:" << b.GetV() << endl;
    	if (IsSame(a, b))
    	{
    		cout << "same" << endl;
    	}
    	else
    	{
    		cout << "not same" << endl;
    	}
    	system("pause");
    	return 0;
    }
    /*
    S_a:600
    S_b:1000
    V_a:1000
    V_b:2000
    not same
    请按任意键继续. . .
    */

### 12对象:构造函数和析构函数? ###

class的类中public下用类名()和~类名()

构造函数是在调用这个类之前的被调用的函数，可以用于给类赋值

析构函数是这个类不再使用后被调用，可以用于将堆区开辟的动态内存释放

#include<iostream>
    using namespace std;
    class Person
    {
    public:
    	//构造函数
    	Person()
    	{
    		cout << "Person的构造函数调用" << endl;
    	}
    	//析构函数
    	~Person()
    	{
    		cout << "Person的析构函数调用" << endl;
    	}
    
    };
    
    void test01()
    {
    	Person p;
    }
    
    int main() {
    
    	test01();
    
    	system("pause");
    	return 0;
    }
    /*
    Person的构造函数调用
    Person的析构函数调用
    请按任意键继续. . .
    */

### 13有参构造和无参构造 ###

有参构造：调用时传入参数，函数要自己编写，并在函数参数中写上函数参数，Person p(10);

无参构造：操作系统默认Person()\{\}

#include<iostream>
    using namespace std;
    
    //1、构造函数分类
    // 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
    // 按照类型分类分为 普通构造和拷贝构造
    
    class Person {
    public:
    	//无参（默认）构造函数
    	Person() {
    		cout << "无参构造函数!" << endl;
    	}
    	//有参构造函数
    	Person(int a) {
    		age = a;
    		cout << "有参构造函数!" << endl;
    	}
    	//拷贝构造函数
    	Person(const Person& p) {
    		age = p.age;
    		cout << "拷贝构造函数!" << endl;
    	}
    	//析构函数
    	~Person() {
    		cout << "析构函数!" << endl;
    	}
    public:
    	int age;
    };
    
    //2、构造函数的调用
    //调用无参构造函数
    void test01() {
    	Person p; //调用无参构造函数
    }
    
    //调用有参的构造函数
    void test02() {
    
    	//2.1  括号法，常用
    	Person p1(10);
    	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
    	//Person p2();
    	//void func();
    
    	//2.2 显式法
    	Person p2 = Person(10); 
    	Person p3 = Person(p2);
    	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构
    	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
    	//Person (p3)//p3重定义
    
    	//2.3 隐式转换法
    	Person p4 = 10; // Person p4 = Person(10); 
    	Person p5 = p4; // Person p5 = Person(p4); 
    }
    
    int main() {
    
    	test01();
    	//test02();
    
    	system("pause");
    
    	return 0;
    }

### 14普通构造和拷贝构造 ###

普通构造：传参或者不传参

拷贝构造：新拷旧，值传递旧，返回值为类对象

#include<iostream>
    using namespace std;
    class Person {
    public:
    	Person() {
    		cout << "无参构造函数!" << endl;
    		mAge = 0;
    	}
    	Person(int age) {
    		cout << "有参构造函数!" << endl;
    		mAge = age;
    	}
    	Person(const Person& p) {
    		cout << "拷贝构造函数!" << endl;
    		mAge = p.mAge;
    	}
    	//析构函数在释放内存之前调用
    	~Person() {
    		cout << "析构函数!" << endl;
    	}
    public:
    	int mAge;
    };

int main() {
    
    	//test01();
    	//test02();
    	test03();
    
    	system("pause");
    
    	return 0;
    }

*  使用一个已经创建完毕的对象来初始化一个新对象

//1. 使用一个已经创建完毕的对象来初始化一个新对象
    void test01() {
    
    	Person man(100); //p对象已经创建完毕
    	Person newman(man); //调用拷贝构造函数
    	Person newman2 = man; //拷贝构造
    
    	//Person newman3;
    	//newman3 = man; //不是调用拷贝构造函数，赋值操作
    }

*  值传递的方式给函数参数传值

//2. 值传递的方式给函数参数传值
    //相当于Person p1 = p;
    void doWork(Person p1) {}
    void test02() {
    	Person p; //无参构造函数
    	doWork(p);
    }

*  以值方式返回局部对象

//3. 以值方式返回局部对象
    Person doWork2()
    {
    	Person p1;
    	cout << (int*)&p1 << endl;
    	return p1;
    }
    
    void test03()
    {
    	Person p = doWork2();
    	cout << (int*)&p << endl;
    }

### 15深拷贝与浅拷贝 ###

浅拷贝：编译器默认浅拷贝，如果成员属性有在堆区开辟空间，会导致堆区的内存重复释放

假设new了一块空间用指针p指向，p1的成员p指针指向的空间地址为0x0011，系统Person p2(p1)后p2的指针p也指向0x0011，析构p1后，0x0011归还操作系统，但是在析构p2的时候，又释放0x0011，导致内存重复释放

深拷贝：自己提供拷贝函数，在堆区重新申请空间，进行拷贝操作

#include<iostream>
    using namespace std;
    
    class Person {
    public:
    	//无参（默认）构造函数
    	Person() {
    		cout << "无参构造函数!" << endl;
    	}
    	//有参构造函数
    	Person(int age ,int height) {
    		
    		cout << "有参构造函数!" << endl;
    
    		m_age = age;
    		m_height = new int(height);
    		
    	}
    	//拷贝构造函数  
    	Person(const Person& p) {
    		cout << "拷贝构造函数!" << endl;
    		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
    		//m_height = p.m_height;编译器默认实现就是这行代码
    		m_age = p.m_age;
    		m_height = new int(*p.m_height);
    		
    	}
    
    	//析构函数
    	~Person() {
    		cout << "析构函数!" << endl;
    		if (m_height != NULL)
    		{
    			delete m_height;
    		}
    	}
    public:
    	int m_age;
    	int* m_height;
    };
    
    void test01()
    {
    	Person p1(18, 180);
    
    	Person p2(p1);
    
    	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
    
    	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
    }
    
    int main() {
    
    	test01();
    
    	system("pause");
    
    	return 0;
    }

### 16构造函数初始化列表 ###

可以在析构函数右加:成员属性（传入变量名），成员属性2（传入变量名2）

#include<iostream>
    using namespace std;
    
    class Person {
    public:
    	/*无初始化列表：一个个赋值很麻烦
    	Person(int a,int b)
    	{
    		m_A = a;
    		m_B = b;
    	}
    	*/
    	//初始化列表
    	Person(int a, int b) :m_A(a), m_B(b) {}
    
    public:
    	int m_A;
    	int m_B;
    };
    
    
    int main() {
    	Person(10, 20);
    	system("pause");
    	return 0;
    }

### 17静态成员 ###

类内声明类外赋值

class Person {
    public:
    	static int m_A;
    };
    int Person::m_A = 20;

调用：通过创建对象然后调用，不同对象共用相同的数据m\_A

也可以通过类调用，Person::m\_A

###    18静态成员函数 ###

类内声明类外赋值

class Person {
    public:
    	static void func(){};
    };
    void Person::func(){};

调用：通过创建对象然后调用，不同对象共用相同的函数

也可以通过类调用，Person::func()

静态成员函数只能访问静态成员变量

### 19this指针 ###

非静态成员函数共用函数，为了区分不同对象调用成员函数不知道是谁调用的，设计出this指针

this指针指向被调用的成员函数所属的对象

*  当形参和成员变量同名时，可用this指针来区分
 *  在类的非静态成员函数中返回对象本身，可使用return \*this

Person& PersonAddPerson(Person p)
    	{
    		this->age += p.age;
    		//返回对象本身
    		return *this;
    	}

p2.PersonAddPerson(p1).PersonAddPerson(p1).PersonAddPerson(p1);

### 20空指针访问成员函数 ###

类名\* p=NULL;

p->成员函数();

其中成员函数不能含有this指针

如果有this指针并想用空指针访问成员函数，就要加上下面一句

if (this == NULL) \{  
            return;  
        \}

### 21const修饰成员函数 ###

const加在()后

const修饰成员函数，this指针指向的成员变量不能改，mutable变量能改

**常对象：const修饰对象**

常对象的成员变量不能改，但加了mutable的成员变量能改

#include<iostream>
    using namespace std;
    class Person {
    public:
    	Person() {
    		m_A = 0;
    		m_B = 0;
    	}
    
    	//this指针的本质是一个指针常量，指针的指向不可修改
    	//如果想让指针指向的值也不可以修改，需要声明常函数
    	void ShowPerson() const {
    		//const Type* const pointer;
    		//this = NULL; //不能修改指针的指向 Person* const this;
    		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的
    
    		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
    		this->m_B = 100;
    	}
    
    	void MyFunc() const {
    		//mA = 10000;
    	}
    
    public:
    	int m_A;
    	mutable int m_B; //可修改 可变的
    };
    
    
    //const修饰对象  常对象
    void test01() {
    
    	const Person person; //常量对象  
    	cout << person.m_A << endl;
    	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
    	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量
    
    	//常对象访问成员函数
    	person.MyFunc(); //常对象不能调用const的函数
    
    }
    
    int main() {
    
    	test01();
    
    	system("pause");
    
    	return 0;
    }

### 22友元 ###

*  全局函数做友元

将全局函数的函数声明前加上friend ，拷贝到类中

*  类做友元

将朋友类的声明前加friend ，考到类中

*  成员函数做友元

将朋友类中的一个函数的声明前加friend ，在返回值和函数名中间加上朋友类的作用域，考到类中

### 23加号运算符重载 ###

赋予operator后的运算符新的能力，可以实现原先运算符无法对类进行操作的缺点

Person operator+(const Person& p) {
    	Person temp;
    	temp.m_A = this->m_A + p.m_A;
    	temp.m_B = this->m_B + p.m_B;
    	return temp;
    }
    
    全局函数实现 运算符重载
    Person operator+(const Person& p1, const Person& p2) {
    	Person temp(0, 0);
    	temp.m_A = p1.m_A + p2.m_A;
    	temp.m_B = p1.m_B + p2.m_B;
    	return temp;
    }

### 24左移输出运算符重载 ###

//全局函数
    ostream& operator<<(ostream& out, Person& p) {
    	out << "a:" << p.m_A << " b:" << p.m_B;
    	return out;
    }
    //类中
    friend ostream& operator<<(ostream& out, Person& p);
    //使用
    Person p(10,20);
    cout<<p<<endl;

### 25递增运算符重载 ###

前置递增：返回引用，可以一直对同一个数进行操作，若非引用，则相当于传值，传了一个副本，套娃时出错

后置递增：都是重置++会导致函数重定义问题，可以提供占位参数int，让编译器知道这是后置的++，由于返回的是临时变量，所以返回值不能加引用

#include<iostream>
    using namespace std;
    class MyInteger {
    
    	friend ostream& operator<<(ostream& out, MyInteger myint);
    
    public:
    	MyInteger() {
    		m_Num = 0;
    	}
    	//前置++
    	MyInteger& operator++() {
    		//先++
    		m_Num++;
    		//再返回
    		return *this;
    	}
    
    	//后置++
    	MyInteger operator++(int) {
    		//先返回
    		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
    		m_Num++;
    		return temp;
    	}
    
    private:
    	int m_Num;
    };
    
    
    ostream& operator<<(ostream& out, MyInteger myint) {
    	out << myint.m_Num;
    	return out;
    }
    
    
    //前置++ 先++ 再返回
    void test01() {
    	MyInteger myInt;
    	cout << ++myInt << endl;
    	cout << myInt << endl;
    }
    
    //后置++ 先返回 再++
    void test02() {
    
    	MyInteger myInt;
    	cout << myInt++ << endl;
    	cout << myInt << endl;
    }
    
    int main() {
    
    	test01();
    	//test02();
    
    	system("pause");
    
    	return 0;
    }

### 26赋值运算符重载 ###

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

Person& operator=(Person &p)
    	{
    		if (m_Age != NULL)
    		{
    			delete m_Age;
    			m_Age = NULL;
    		}
    		//编译器提供的代码是浅拷贝
    		//m_Age = p.m_Age;
    
    		//提供深拷贝 解决浅拷贝的问题
    		m_Age = new int(*p.m_Age);
    
    		//返回自身
    		return *this;
    	}

### 27关系运算符重载 ###

bool operator==(Person & p)
    	{
    		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    		{
    			return true;
    		}
    		else
    		{
    			return false;
    		}
    	}
    
    	bool operator!=(Person & p)
    	{
    		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
    		{
    			return false;
    		}
    		else
    		{
    			return true;
    		}
    	}

### 28函数调用运算符重载，仿函数 ###

#include<iostream>
    #include<string>
    using namespace std;
    class MyPrint
    {
    public:
    	void operator()(string text)
    	{
    		cout << text << endl;
    	}
    
    };
    void test01()
    {
    	//重载的（）操作符 也称为仿函数
    	MyPrint myFunc;
    	myFunc("hello world");
    }
    
    
    class MyAdd
    {
    public:
    	int operator()(int v1, int v2)
    	{
    		return v1 + v2;
    	}
    };
    
    void test02()
    {
    	MyAdd add;
    	int ret = add(10, 10);
    	cout << "ret = " << ret << endl;
    
    	//匿名对象调用  
    	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
    }
    
    int main() {
    
    	test01();
    	test02();
    
    	system("pause");
    
    	return 0;
    }

### 30为什么要有继承？ ###

为了减少不同类之间相同的重复代码，可以将重复部分单独搞个类出来，在其它类的class 类名后加上：继承类型 共有的类名

多继承：一个类继承多个类，多继承中如果父类中出现了同名情况，子类使用时候要加作用域

### 31继承有几种？ ###

子访问不到父private，但继承下去

*  公共继承：继承类型public：父子同public，protected
 *  保护继承：继承类型protected：父public，protected，子protected
 *  私有继承：继承类型private：父public，protected，子private

父构，子构，析反

### 32父子同名成员，同名成员函数，同名静态成员 ###

1.  子类对象可以直接访问到子类中同名成员
2.  子类对象加作用域可以访问到父类同名成员
3.  当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

### 33vbptr虚基类指针解决菱形继承问题？ ###

*  菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
 *  利用虚继承可以解决菱形继承问题
 *  相当于之后只保留最后的对成员变量改变后的值

#include<iostream>
    using namespace std;
    class Animal
    {
    public:
    	int m_Age;
    };
    
    //继承前加virtual关键字后，变为虚继承
    //此时公共的父类Animal称为虚基类
    class Sheep : virtual public Animal {};
    class Tuo   : virtual public Animal {};
    class SheepTuo : public Sheep, public Tuo {};
    
    void test01()
    {
    	SheepTuo st;
    	st.Sheep::m_Age = 100;
    	st.Tuo::m_Age = 200;
    
    	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
    	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
    	cout << "st.m_Age = " << st.m_Age << endl;
    }
    
    
    int main() {
    
    	test01();
    
    	system("pause");
    
    	return 0;
    }

st.Sheep::m_Age = 200
    st.Tuo::m_Age = 200
    st.m_Age = 200
    请按任意键继续. . .

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70]: /images/20221024/50c48ab8601343348b60fd3d9ee722cd.png