C++核心编程

本阶段主要针对C++ 偏程技术做详细讲解，探讨C++ 中的核心和精髓。

1 内存分区模型

C++程序在执行时，将内存大方向划分为4个区域

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

内存四区意义：

不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程

1.1 程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域

代码区：

• 存放CPU执行的机器指令
• 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
• 代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令

全局区：

• 全局变量和静态变量存放在此
• 全局区还包含了常量区，字符串常量和其他常量也存放在此
• 该区域的数据在程序结束后由操作系统释放

示例代码：

#include <iostream>

// 全局变量
int g_a = 1;
int g_b = 1;

int main() {
	

	std::cout << "全局变量g_a " << (int) & g_a << "\n";
	std::cout << "全局变量g_b " << (int) & g_b << "\n";

	// 静态变量
	static int s_a = 1;
	static int s_b = 1;
	std::cout << "静态变量s_a " << (int)&s_a << "\n";
	std::cout << "静态变量s_b " << (int)&s_b << "\n";


	// 字符串常量 
	std::cout << "字符串常量 " << (int)&"helloworld\n";

	std::cin.get();

	return 0;
}

总结：

• C++中在程序运行前分为全局区和代码区
• 代码区特点是共享和只读
• 全局区中存放全局变量、静态变量、常量
• 常量区中存放const修饰的全局常量和字符串常量

1.2 程序运行后

栈区：

• 由编译器自动分配释放，存放函数的参数值，局部变量等
• 注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

堆区：

• 由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
• 在C++中主要利用new在堆区开辟内存

总结：

• 堆区数据由程序员管理开辟和释放
• 堆区数据利用new关键字进行开辟内存

1.3 new操作符

• C++中利用new操作符在堆区开辟数据
• 堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
• 语法：new数据类型
• 利用new创建的数据，会返回该数据对应的类型的指针

2 函数占位参数

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

语法：返回值类型函数名{(数据类型)}

#include <iostream>
#include <Windows.h>

void f(int a, int) {
	std::cout << a << std::endl;
}

int main() {
	f(10, 10);
	system("pause");
	return 0;
}

3 构造函数的调用

三种调用方式：

• 括号法
• 显示法
• 隐式转换法

#include <iostream>

class Person {
public:
	// 构造函数
	Person() {
		std::cout << "Person的无参构造函数调用" << std::endl;
	}
	Person(int a) {
		age = a;
		std::cout << "Person的有参构造函数调用" << std::endl;
	}
	// 拷贝构造函数
	Person(const Person& p) {
		// 将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
		std::cout << "Person的拷贝构造函数调用" << std::endl;
	}

	~Person() {
		std::cout << "Person的析构函数调用" << std::endl;
	}

	int age;
};


// 调用
void test01() {
	
	/*
	// 1. 括号法
	Person p;	// 默认
	Person p1(10); // 有参
	Person p2(p1); // 拷贝
	std::cout << p1.age << std::endl;
	std::cout << p2.age << std::endl;

	// 注意事项
	// 调用默认构造函数的时候，不要加()
	// 因为下面这行代码，编译器会认为是一个函数的声明，不会认为在创建对象
	// Person p();
	*/

	// 2. 显示法
	Person p1;
	Person p2 = Person(10); // 调用有参构造函数
	Person p3 = Person(p2);	// 拷贝构造
	
	//Person(10); // 匿名对象  特点：当前行执行结束后，系统会立即回收掉匿名对象
	//std::cout << "aa" << std::endl;

	// 注意事项 2
	// 不要利用拷贝构造函数 初始化匿名对象 编译器会认为 Person(p3) 等价于 Person p3; 会认为是对象声明
	//Person(p3);

	// 3. 隐式转换法
	Person p4 = 10; // 相当于 写了 Person p4 = Person(10);
	Person p5 = p4; // 拷贝构造
}


int main() {

	test01();
	return 0;
}

4 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

• 使用一个已经创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值
• 以值方式返回局部对象

示例

#include <iostream>

class Person {
public:
	Person() {
		std::cout << "Person默认构造函数调用" << std::endl;
	}
	Person(int a) {
		age = a;
		std::cout << "Person有参构造函数调用" << std::endl;
	}
	Person(const Person& p) {
		age = p.age;
		std::cout << "Person拷贝构造函数调用" << std::endl;
	}
	~Person() {
		std::cout << "Person析构构造函数调用" << std::endl;
	}

	int age;
};


// 1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person p1(20);
	Person p2(p1);
	std::cout << p2.age << std::endl;
}

// 2. 值传递的方式给函数参数传值

void doWork(Person p) {

}

void test02() {
	Person p;
	doWork(p);
}

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

void test03() {
	Person p = doWork2();	
	std::cout << (int*)&p << std::endl;
} 


int main() {

	//test01();
	//test02();
	test03();
	return 0;
}

5 构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数 (无参，函数体为空)
3. 默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

• 如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，C++不会再提供其他构造函数

#include <iostream>


// 构造函数的调用规则
// 1. 创建一个类，C++编译器会给每个类都添加至少3个函数
// 默认构造 (空实现)
// 析构函数 (空实现)
// 拷贝构造 (值拷贝) 




class Person {
public:
	//Person() {
	//	std::cout << "Person默认构造函数调用" << std::endl;
	//}
	//Person(int a) {
	//	age = a;
	//	std::cout << "Person有参构造函数调用" << std::endl;
	//}
	Person(const Person& p) {
		age = p.age;
		std::cout << "Person拷贝构造函数调用" << std::endl;
	}
	~Person() {
		std::cout << "Person析构函数调用" << std::endl;
	}

	int age;
};

//void test01() {
//	Person p;
//	p.age = 18;
//
//	Person p2(p);
//	std::cout << "p2的年龄为: " << p2.age << std::endl;
//}

// 如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
void test02() {
	Person p(28);
	Person p2(p);
	std::cout << "p2的年龄为: " << p2.age << std::endl;
}

// 如果我们写了拷贝构造函数，编译器就不再提供其他普通构造函数了

int main() {

	//test01();
	test02();
	return 0;
}

6 深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

#include <iostream>

class Person {
public:
    Person() {
        std::cout << "Person默认构造函数调用" << std::endl;
    }
    Person(int a, int height) {
        age = a;
        Height = new int(height);
        std::cout << "Person有参构造函数调用" << std::endl;
    }
    Person(const Person& p) {
        std::cout << "Person拷贝构造函数调用" << std::endl;
        age = p.age;
        // Height = p.Height; 编译器默认实现就是这行代码
        // 深拷贝操作
        Height = new int(*p.Height);
    }
    ~Person() {
        // 析构代码 ，将堆区开辟数据做释放操作
        if (Height != NULL) {
            delete Height;
            Height = nullptr;
        }
        std::cout << "Person析构函数调用" << std::endl;
    }

    int age;
    int* Height;
};

void test01() {
    Person p1(18, 160);
    std::cout << "p1的年龄为：" << p1.age << " p1身高" << *p1.Height
        << std::endl;
    Person p2(p1);
    std::cout << "p2的年龄为：" << p2.age << " p2身高" << *p2.Height
        << std::endl;
}

int main() {
    test01();
    return 0;
}

总结：如果属性有在堆区开辟的，一定要自己提供接贝构造函数，防止浅拷贝带来的问题

7 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

• 静态成员变量
  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化
• 静态成员函数
  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量

示例1： 静态成员变量

#include <iostream>

class Person {
public:


	// 1. 所有对象都共享同一份数据
	// 2. 编译阶段就分配内存
	// 3. 类内声明，类外初始化操作 
	static int m_A;
private:
	static int m_B;
};

int Person::m_A = 100;
int Person::m_B = 200;

void test01() {
	Person p;
	// 100
	std::cout << p.m_A << std::endl;
	Person p1;
	p1.m_A = 200;
	// 200
	std::cout << p.m_A << std::endl;
	std::cout << p1.m_A << std::endl;
}

void test02() {
	// 静态成员变量 不属于某个对象上，所有对象都共享同一份数据
	// 因此静态成员变量有两种访问方式
	
	// 1. 通过对象进行访问
	Person p;
	std::cout << p.m_A << std::endl;

	// 2. 通过类名进行访问
	std::cout << Person::m_A << std::endl;

	// std::cout << Person::m_B << std::endl; 类外访问不到私有静态成员变量
}

int main() {
	//test01();
	test02();
	return 0;
}

示例2： 静态成员函数

#include <iostream>

// 静态成员函数
// 所有对象共享同一个函数
// 静态成员函数只能访问静态成员变量

class Person {
public:
	// 静态成员函数
	static void func() {
		m_A = 100; // 静态成员函数可以访问 静态成员变量		
		//m_B = 200;	// 静态成员函数 不可以访问 非静态成员变量 无法区分到底是哪个对象的m_B属性
		std::cout << "static void func调用" << std::endl;
	}

	static int m_A; // 静态成员变量
	int m_B;	// 非静态成员变量

	// 静态成员函数也是有访问权限的	
private:
	static void func2() {
		std::cout << "static void func2" << std::endl;
	}
};

int Person::m_A = 0;

// 有两种访问方式
void test01() {
	// 1. 通过对象访问
	Person p;
	p.func();

	// 2. 通过类名访问
	Person::func();

	// Person::func2(); 类外访问不到私有静态成员函数
}

int main() {
	test01();
	return 0;
}

8 成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

#include <iostream>

// 成员变量 和 成员函数 分开存储的

class Person {
	int m_A; // 非静态成员变量 属于类的对象上

	static int m_B; // 静态成员变量 不属于类的对象上

	void func() {}; // 非静态成员函数 不属于类的对象上

	static void func2() {}; // 静态成员函数 不属于类的对象上
};

int Person::m_B = 0;

void test01() {
	Person p;
	// 空对象占用内存空间为：1
	// C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	// 每个空对象也应该有一个独一无二的内存地址
	std::cout << "size of p =" << sizeof(p) << std::endl;
}

void test02() {
	Person p;
	std::cout << "size of p =" << sizeof(p) << std::endl;
}


int main() {
	//test01();
	test02();
	return 0;
}

9 this指针概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分那个对象调用自己的呢？

C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的用途：

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

#include <iostream>

class Person {
public:
	Person(int age) {
		// this指针指向 被调用的成员函数 所属的对象
		this->age = age;
	}
	
	Person& PersonAddAge(Person& p) {
		this->age += p.age;

		// this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}

	int age;
};

// 1. 解决名称冲突
void test01() {
	Person p1(19);
	std::cout << p1.age << std::endl;
}

// 2. 返回对象本身用 *this
void test02() {
	Person p1(10);

	Person p2(10);

	// 链式编程思想
	Person p = p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	// Person p = Person(tempP);

	std::cout << p.age << std::endl;

}

int main() {

	test02();
	return 0;
}

10 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

#include <iostream>

// 空指针调用成员函数
class Person {
public:
	void showClassName() {
		std::cout << "this is Person class" << std::endl;
	}

	void showPersonAge() {
		// 报错原因是因为传入的指针是NULL
		if (this == NULL) {
			return; 
		}
		std::cout << "age = " << m_Age << std::endl;
	}

	int m_Age;
};

void test01() {
	Person* p = NULL;
	p->showClassName();
	p->showPersonAge();
}

int main() {
	test01();
	return 0;
}

11 const修饰成员函数

常函数：

• 成员函数后加const后我们称为这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数

示例：

#include <iostream>

// 常函数
class Person {
public:
	// this指针的本质 是指针常量 指针的指向是不可以修改的
	// const Person * const this;
	// 在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改
	void showPerson() const {
		this->m_B = 100;
		//this->m_A = 100;
		//this = NULL; // this指针不可以修改修改的指向的
	}

	void func() {

	}

	int m_A;
	mutable int m_B; // 特殊变量，即使在常函数中，也可以修改这个值，加关键字mutable
};

void test01() {
	Person p;
	p.showPerson(); 
}

// 常对象
void test02() {
	const Person p;	// 在对象前加const，变为常对象
	//p.m_A = 100;
	p.m_B = 100;	// m_B是特殊值，在常对象下也可以修改
	
	// 常对象只能调用常函数
	p.showPerson();
	//p.func();	// 常对象 不可以调用普通成员函数，因为普通成员函数可以修改属性
}

int main() {
	return 0;
}

12 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

12.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

#include <iostream>

// 加号运算符重载

class Person {
public:
	// 1. 成员函数重载+号
	/*Person operator+(Person& p) {
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}*/
	int m_A;
	int m_B;
};

// 2. 全局函数重载+号
Person operator+(Person& p1, Person& p2) {
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

// 函数重载的版本
Person operator+(Person& p1, int num) {
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01() {
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	// 成员函数重载本质调用
	//Person p3 = p1.operator+(p2);
	
	// 全局函数重载本质调用
	Person p3 = operator+(p1, p2);

	//Person p3 = p1 + p2;
	// 运算符重载 也可以发生函数重载

	Person p4 = p1 + 100;

	std::cout << p3.m_A << "\n" << p3.m_B << std::endl;
	std::cout << p4.m_A << "\n" << p4.m_B << std::endl;
}

int main() {
	test01();
	return 0;
}

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的

总结2：不要滥用运算符重载

12.2 左移运算符重载

作用：可以输出自定义数据类型

#include <iostream>

// 左移运算符重载
class Person {
	friend std::ostream& operator<<(std::ostream& cout, Person& p);
public:
	Person(int a, int b) {
		m_A = a;
		m_B = b;
	}
private:
	
	// 利用成员函数重载 左移运算符 p.operator<<(cout) 简化版本 p << cout
	// 不会利用成员函数重载<<运算符 因为无法实现 cout在左侧
	/*void operator<<(cout) {

	}*/

	int m_A;
	int m_B;
};

// 只能利用全局函数重载左移运算符
std::ostream& operator<<(std::ostream& cout, Person& p) {	// 本质 operator<<(cout, p) 简化形式 cout << p
	std::cout << "m_A = " << p.m_A << " m_B=" << p.m_B;
	return cout;
}

void test01() {
	Person p(10, 10);
	std::cout << p << std::endl;
}

int main() {

	test01();

	return 0;
} 

总结：重载左移运算符配合友元可以实现输出自定义数据类型

12.3 递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

#include <iostream>

class MyInteger {
	friend std::ostream& operator<<(std::ostream& cout, MyInteger myint);
public:
	MyInteger() {
		m_Num = 0;	
	}

	// 重载前置++运算符 返回引用为了一直对一个数据进行递增操作
	MyInteger& operator++() {
		// 先进行++运算
		m_Num++;
		// 再将自身返回
		return *this;
	}

	// 重载后置++运算符
	// void operator++(int) int代表占位参数，可以用于区分前置和后置递增
	MyInteger operator++(int) {
		// 先 记录当时结果
		MyInteger temp = *this;
		// 后递增
		m_Num++;	
		// 最后将记录结果做返回
		return temp;
	}

private:
	int m_Num;
};

// 重载<<运算符
std::ostream& operator<<(std::ostream& cout, MyInteger myint) {
	std::cout << myint.m_Num;
	return cout;
}


void test01() {
	MyInteger myint;
	std::cout << ++(++myint) << std::endl;
	std::cout << myint << std::endl;
}

void test02() {
	MyInteger myint;
	std::cout << myint++ << std::endl;
	std::cout << myint << std::endl;
}

int main() {
	//test01();
	test02();
	return 0;
}

12.4 赋值运算符重载

C++编译器至少给一个类添加4个函数

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数，对属性进行值拷贝
4. 赋值运算符operator=，对属性进行值拷贝

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

示例：

#include <iostream>

// 赋值运算符重载
class Person {
public:
	Person(int age) {
		m_Age = new int(age);
	}

	~Person() {
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}
	}

	// 重载 赋值运算符
	Person& operator=(Person &p) {
		// 编译器是提供浅拷贝
		//m_Age = p.m_Age;

		// 应该先判断是否有属性再堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}

		// 深拷贝
		m_Age = new int(*p.m_Age);

		return *this;
	}

	int* m_Age;
};


void test01() {
	Person p1(18);
	Person p2(20);
	Person p3(30);
	p3 = p2 = p1 ;	// 赋值操作
	std::cout << *p1.m_Age << std::endl;
	std::cout << *p2.m_Age << std::endl;
	std::cout << *p3.m_Age << std::endl;
}

int main() {
	test01();
	return 0;
}

12.5 关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

示例：

#include <iostream>
#include <string>

// 重载关系运算符

class Person {
public:

	Person(std::string name, int age) {
		m_Name = name;
		m_Age = age;
	}

	// 重载 == 号
	bool operator==(Person &p) {
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age) {
			return true;
		}
		return false;
	}

	std::string m_Name;
	int m_Age;

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

};


void test01() {
	Person p1("Tom", 18);
	Person p2("Tom", 18);

	if (p1 == p2) {
		std::cout << "p1 和 p2 相等\n";
	}
	else {
		std::cout << "p1 和 p2 不相等\n";
	}

	if (p1 != p2) {
		std::cout << "p1 和 p2 不相等\n";
	}
	else {
		std::cout << "p1 和 p2 相等\n";
	}
}

int main() {
	test01();
	return 0;
}

12.6 函数调用运算符重载

• 函数调用运算符（）也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

示例：

#include <iostream>
#include <string>

// 函数调用运算符重载
  
// 打印输出类
class MyPrint {
public:
	
	// 重载函数调用运算符
	void operator()(std::string text) {
		std::cout << text << std::endl;
	}
};

void MyPrint02(std::string text) {
	std::cout << text << std::endl;
}

void test01() {
	MyPrint myPrint;

	myPrint("Hello World");	// 由于使用起来非常类似函数调用，因此称为仿函数

	MyPrint02("Hello World");
}

// 仿函数非常灵活，没有固定的写法
// 加法类
class MyAdd {
public:
	int operator()(int num1, int num2) {
		return num1 + num2;
	}

};

void test02() {
	MyAdd myAdd;
	int ret = myAdd(100, 10);
	std::cout << ret << std::endl;

	// 匿名函数对象
	std::cout << MyAdd()(100, 100) << std::endl;
}

int main() {

	test01();
	return 0;
}

13 继承

13.1 继承中的对象模型

报告单个类的布局

利用开发人员命令提示工具查看对象模型

cl /d1 reportSingleClassLayout类名 文件名

13.2 菱形继承

菱形继承概念：

• 两个派生类继承同一个基类
• 又有某个类同时继承者两个派生类
• 这种继承被称为菱形继承，或者钻石继承

#include <iostream>

// 动物类
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 = 18;
	st.Tuo::m_Age = 28;
	// 当菱形继承，两个父类拥有相同数，需要加以作用域区分
	std::cout << st.Sheep::m_Age << "\n" << st.Tuo::m_Age;
	std::cout << st.m_Age << std::endl;
	// 这份数据我们知道 只有有一份就可以，菱形继承导致数据有两份，资源浪费
}


int main() {
	test01();
	return 0;
}

总结：

• 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
• 利用虚继承可以解决菱形继承问题

13 继承

13.1 继承中的对象模型

报告单个类的布局

利用开发人员命令提示工具查看对象模型

cl /d1 reportSingleClassLayout类名 文件名

13.2 菱形继承

菱形继承概念：

• 两个派生类继承同一个基类
• 又有某个类同时继承者两个派生类
• 这种继承被称为菱形继承，或者钻石继承

#include <iostream>

// 动物类
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 = 18;
	st.Tuo::m_Age = 28;
	// 当菱形继承，两个父类拥有相同数，需要加以作用域区分
	std::cout << st.Sheep::m_Age << "\n" << st.Tuo::m_Age;
	std::cout << st.m_Age << std::endl;
	// 这份数据我们知道 只有有一份就可以，菱形继承导致数据有两份，资源浪费
}


int main() {
	test01();
	return 0;
}

总结：

• 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
• 利用虚继承可以解决菱形继承问题