C++核心编程
文章目录
- 1 内存分区模型
-
- 1.1 程序运行前
- 1.2 程序运行后
- 1.3 new操作符
- 2 函数占位参数
- 3 构造函数的调用
- 4 拷贝构造函数调用时机
- 5 构造函数调用规则
- 6 深拷贝与浅拷贝
- 7 静态成员
- 8 成员变量和成员函数分开存储
- 9 this指针概念
- 10 空指针访问成员函数
- 11 const修饰成员函数
- 12 运算符重载
-
- 12.1 加号运算符重载
- 12.2 左移运算符重载
- 12.3 递增运算符重载
- 12.4 赋值运算符重载
- 12.5 关系运算符重载
- 12.6 函数调用运算符重载
- 13 继承
-
- 13.1 继承中的对象模型
- 13.2 菱形继承
- 13.2 菱形继承
本阶段主要针对C++ 偏程技术做详细讲解，探讨C++ 中的核心和精髓。
1 内存分区模型
C++程序在执行时，将内存大方向划分为4个区域
- 代码区：存放函数体的二进制代码，由操作系统进行管理的
- 全局区(数据区)：存放全局变量和静态变量以及常量
- 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
- 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
内存四区意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程
1.1 程序运行前
在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域
代码区：
- 存放CPU执行的机器指令
- 代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
- 代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
- 全局变量和静态变量存放在此
- 全局区还包含了常量区，字符串常量和其他常量也存放在此
- 该区域的数据在程序结束后由操作系统释放
示例代码：
#include
// 全局变量
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
#include
void f(int a, int) {
std::cout << a << std::endl;
}
int main() {
f(10, 10);
system("pause");
return 0;
}
3 构造函数的调用
三种调用方式：
- 括号法
- 显示法
- 隐式转换法
#include
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
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个函数
- 默认构造函数（无参，函数体为空）
- 默认析构函数 (无参，函数体为空)
- 默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下：
- 如果用户定义有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数，C++不会再提供其他构造函数
#include
// 构造函数的调用规则
// 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
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
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
// 静态成员函数
// 所有对象共享同一个函数
// 静态成员函数只能访问静态成员变量
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
// 成员变量 和 成员函数 分开存储的
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
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
// 空指针调用成员函数
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
// 常函数
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
// 加号运算符重载
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
// 左移运算符重载
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
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个函数
- 默认构造函数（无参，函数体为空）
- 默认析构函数（无参，函数体为空）
- 默认拷贝构造函数，对属性进行值拷贝
- 赋值运算符operator=，对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
示例：
#include
// 赋值运算符重载
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
#include
// 重载关系运算符
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
#include
// 函数调用运算符重载
// 打印输出类
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
// 动物类
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;
}
总结：
- 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
- 利用虚继承可以解决菱形继承问题
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 继承中的对象模型
**报告单个类的布局**
利用开发人员命令提示工具查看对象模型
```powershell
cl /d1 reportSingleClassLayout类名 文件名
13.2 菱形继承
菱形继承概念：
- 两个派生类继承同一个基类
- 又有某个类同时继承者两个派生类
- 这种继承被称为菱形继承，或者钻石继承
#include
// 动物类
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;
}
总结：
- 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
- 利用虚继承可以解决菱形继承问题