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;// 100std::cout << p.m_A << std::endl;Person p1;p1.m_A = 200;// 200std::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() {// 报错原因是因为传入的指针是NULLif (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 << pstd::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;
}

总结：

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

总结：

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