目录
1.类
1.1 C++中可以使用struct、class来定义一个类
1.1.1 struct 和 class的区别
1）struct 的默认成员权限是 public
2）class 的默认权限是 private (实际开发中使用class)
使用class创建一个类
#include <iostream>
using namespace std;
class Person {
public:
//成员变量（属性）
int age;
//成员函数（ 方法）
void run() {
cout << "Person::run()-" << age << endl;
}
};
int main() {
//实例化-利用类创建对象
Person person;
person.age = 20;
person.run();
return 0;
}
使用struct 创建一个类
#include <iostream>
using namespace std;
struct Person {
//成员变量（属性）
int age;
//成员函数（ 方法）
void run() {
cout << "Person::run()-" << age << endl;
}
};
int main() {
//实例化-利用类创建对象
Person person;
person.age = 20;
person.run();
return 0;
}
1.1.2 内存的栈空间，自动分配和回收
下面的person对象和p指针的内存都是在函数的栈空间，自动分配和回收
#include <iostream>
using namespace std;
class Person {
public:
//成员变量（属性）
int age;
//成员函数（ 方法）
void run() {
cout << "Person::run()-" << age << endl;
}
};
int main() {
//实例化-利用类创建对象
Person person;
person.age = 20;
person.run();
Person* p = &person;
p->age = 30;
p->run();
return 0;
}
person对象和p指针一共占用12个字节（4字节person+8字节*p）
1.1.3 class与struct的反汇编比较
class 编译的反汇编，如下
mov dword ptr [ebp-0Ch],14h
15: Person person;
16: person.age = 20;
01202672 mov dword ptr [ebp-0Ch],14h
struct 编译的反汇编，如下
mov dword ptr [ebp-0Ch],14h
15: Person person;
16: person.age = 20;
01202672 mov dword ptr [ebp-0Ch],14h
结论：可见class 和 struct反汇编是一致的，也就是说除了 1.1.1的性质区别，class 和 struct本质上是没区别的
1.1.4 创建的对象内存情况
#include <iostream>
using namespace std;
struct Car {
int price;
void run() {
cout << "run()-" << price << endl;
}
};
int main() {
Car car1;
car1.price = 10;
car1.run();
Car car2;
car2.price = 20;
car2.run();
Car car3;
car3.price = 30;
car3.run();
return 0;
}
上面代码的反汇编：
1）每一个 car 对象都在栈空间开辟了4个字节的存储空间
2）可以看出所有的run() 都都被编译成：call 函数地址 ，
3）3个 run() 方法都是call一样的地址，可以看出编译后的run() 方法不与对象产生在同一块内存
1.1.5 函数内存布局：成员函数，不占用创建对象的内存
成员函数（类中的函数） 在创建对象时不会被塞入对象总内存中，而是被编译后单独在内存中（如果不被调用的函数，在编译优化后将不会有内存存储此函数），即创建100个对象，只会有一份函数的内存
调用 成员函数（类中的函数）反汇编为：call 这个函数地址
成员函数（类中的函数）存储的内存与对象存储内存不同
1.1.6 成员变量内存布局：类中的成员变量，以创建对象的成员变量多少开辟内存
类中的成员变量 ，在创建对象时会在内存中开辟成员变量对应类型大小的连续内存（暂不考虑：内存对齐），如int在64位系统占用4个字节，对象的地址量即类中按顺序第一成员变量的地址
下面的对象 car1~car3总计占用 12个字节
1.1.7 C++编程规范
变量名规范参考
| 使用场景 | 方式 | 实例 |
|---|---|---|
| 全局变量 | g_ | g_count |
| 成员变量 | m_ | m_count |
| 静态变量 | s_ | s_count |
| 常量 | c_ | c_count |
2. 对象
1.1 对象的内存布局
1.1.1 类中多个成员变量的内存布局
类中成员变量在内存中是连续的存储
#include <iostream>
using namespace std;
struct Date {
int year;
int month;
int day;
void display() {
cout << "year=" << year
<< "month=" << month
<< "day=" << day << endl;
}
};
int main() {
Date date;
cout << sizeof(date) << endl;
return 0;
}
输出：12
一个 int 占用4个字节（x64、x86相同）
1.1.2 内存中（4个区域）的栈空间
创建类的实例 date（对象）存储在栈空间，且由类内成员变量多少决定
#include <iostream>
using namespace std;
struct Date {
//这个 person 对象内存在栈空间
//栈空间内存会自动回收
int year;
int month;
int day;
void display() {
cout << "year=" << year
<< "month=" << month
<< "day=" << day << endl;
}
};
int main() {
Date date;
date.year = 1;
date.month = 3;
date.day = 5;
cout << "&date=" << &date << endl;
cout << "&date.year="<< &date .year<< endl;
cout << "&date.month=" << &date.month << endl;
cout << "&date.day=" << &date.day << endl;
return 0;
}
3. this
3.1 this 就是指向当前对象的指针
3.2 对象在调用成员函数的时候，会自动传入当前对象的内存地址
可以看到编译器已经帮我们优化好了，将*person指针 演化成this 再到默认为this
3.3 可以利用 this.m_age 来访问成员变量么？
不可以，因为 this 是指针，必须用this->m_age 来访问
1）. 点的左边只能是对象
2）-> 箭头的左边只能是指针
3.4 指针访问对象成员的本质
由上图可以看出 ebp-0Ch 为person1对象的地址值
注意这里2个概念地址值 如：ebp-0Ch 和 地址的存储空间 如：ecx、eax 、[ebp-0Ch]
// ebp-8 是 this指针 的地址
mov dword ptr [ebp-8],ecx 就是将person1对象的地址值存入this地址的存储空间
mov eax,dword ptr [ebp-8] 就是将this地址的存储空间(person1对象的地址值)存入eax
mov dword ptr [eax],3 就是将3赋值给this实际就是person对象地址的存储空间
========================== 汇编代码 ==============================
00A51FA0 mov dword ptr [ebp-8],ecx
19: this->m_age = 3;
00A51FAD mov eax,dword ptr [ebp-8]
00A51FB0 mov dword ptr [eax],3
这里比较绕，大家一定要把代码和反汇编，结合文中的描述一起理解
3.5 类中多成员变量的内存分配
#include <iostream>
using namespace std;
struct Person
{
int m_id;
int m_age;
int m_height;
void display() {
cout << "m_id = " << m_id
<< ",m_age = " << m_age
<< ",m_height = " << m_height << endl;
}
};
int main() {
Person person;
person.m_id = 10;
person.m_age = 20;
person.m_height = 30;
person.display();
Person* p = &person;
p->m_id = 10;
p->m_age = 20;
p->m_height = 30;
p->display();
return 0;
}
上面代码对应的汇编
========================== 对象访问 ==============================
18: Person person;
19: person.m_id = 10;
009B26D2 mov dword ptr [ebp-14h],0Ah
20: person.m_age = 20;
009B26D9 mov dword ptr [ebp-10h],14h
21: person.m_height = 30;
009B26E0 mov dword ptr [ebp-0Ch],1Eh
22: person.display();
009B26E7 lea ecx,[ebp-14h]
009B26EA call 009B104B
========================== 指针访问 ==============================
24: Person* p = &person;
009B26EF lea eax,[ebp-14h]
009B26F2 mov dword ptr [ebp-20h],eax
25: p->m_id = 10;
009B26F5 mov eax,dword ptr [ebp-20h]
009B26F8 mov dword ptr [eax],0Ah
26: p->m_age = 20;
009B26FE mov eax,dword ptr [ebp-20h]
009B2701 mov dword ptr [eax+4],14h
27: p->m_height = 30;
009B2708 mov eax,dword ptr [ebp-20h]
009B270B mov dword ptr [eax+8],1Eh
28: p->display();
009B2712 mov ecx,dword ptr [ebp-20h]
009B2715 call 009B104B
可以看出多成员变量在对象调用中：
1）对象的地址，就是类下第一成员变量的首地址 即如下：ebp-14h
2）多个成员变量在内存中是连续分配的（根据代码区的类下成员代码顺序，且当前为小端模式）
还是要明白2个概念：存储空间 和 地址值（上文提到）
将 ebp-14h 地址值存入eax的存储空间，ebp-14h就是&person
009B26EF lea eax,[ebp-14h]
将eax的存储空间 赋值给 ebp-20h地址指向的存储空间，ebp-20h是p的地址
009B26F2 mov dword ptr [ebp-20h],eax
上面2句就是Person* p = &person;
======= 分割========================================
25: p->m_id = 10;
p指针 存储空间 赋值 eax，eax 存储的就是 person对象的地址值（也是person.m_age的地址值）
009B26F5 mov eax,dword ptr [ebp-20h]
person.m_age =10
009B26F8 mov dword ptr [eax],0Ah
====== 分割========================================
26: p->m_age = 20;
009B26FE mov eax,dword ptr [ebp-20h]
009B2701 mov dword ptr [eax+4],14h
27: p->m_height = 30;
009B2708 mov eax,dword ptr [ebp-20h]
009B270B mov dword ptr [eax+8],1Eh
28: p->display();
009B2712 mov ecx,dword ptr [ebp-20h]
009B2715 call 009B104B
3.6 如何利用指针间接访问所指向对象的成员变量？
3.6.1 从指针中取出对象的地址
看到如下的汇编代码，一定是指针间接访问成员变量
mov eax,dword ptr [ebp-20h]
mov dword ptr [eax],14h
[ [ebp-20h] ]将值作为地址，取其存储空间
3.6.2 利用 对象的地址+成员变量的偏移量计算出成员变量地址
3.6.3 根据成员变量的地址访问成员变量的存储空间
3.7 一道题检测指针与内存
3.7.1 请问person.display();打印结果是？
#include <iostream>
using namespace std;
struct Person
{
int m_id;
int m_age;
int m_height;
void display() {
cout << "m_id = " << m_id
<< ",m_age = " << m_age
<< ",m_height = " << m_height << endl;
}
};
int main() {
Person person;
person.m_id = 10;
person.m_age = 20;
person.m_height = 30;
Person* p = (Person * )&person.m_age;
p->m_id = 40;
p->m_age = 50;
person.display();
return 0;
}
思路2次偏移量寻找
1）第一次查看当前，成员变量的偏移量
p->m_id = 40;
汇编：mov eax,dword ptr [p]
mov dowrd ptr [eax+0],40 // m_id 相对于person地址偏移量为0
p->m_age = 50;
汇编：mov dword ptr [eax+4],50 // m_age 相对于person地址偏移量为 4
2）第二次查看当前，p指针的偏移量
Person* p = (Person * )&person.m_age;
// &person.m_age 当前p指向的是&person.m_age，也就是 &person +4的偏移
3）重新整理
p->m_id = 40;
汇编：mov eax,dword ptr [p]
mov dowrd ptr [eax+0],40
mov dowrd ptr [&person+4+0],40 // 等价于 person.m_age =40
p->m_age = 50;
汇编：mov dword ptr [eax+4],50
mov dowrd ptr [&person+4+4],50 // 等价于 person.m_height =50
最后输出结果
3.7.3 偏移量
这里所指的偏移量，全部是以类下的成员变量书写顺序，也就是类的机器码存放在代码区的顺序
class Person {
public:
int age; // 顺序开始
int height;
...
int phone;// 顺序结束
};
3.7.4 如果 p->display(); 结果和 person.display();又有什么区别呢？
// person 调用 display() 函数 传入的为&person
// 即：display(&person) &person传给this
person.display();
// p 调用 display() 函数 传入的为&person.m_age，因为age为&person偏移4个字节
// 即：display(&person+4) &person+4传给this
p->display();
m_height = -858993460 这个结果是 cc
3.7.5 cc -> int3 指令
0xccccccc
cc->int3：起到断点的作用 （interrupt 中断）
4. 封装
4.1 封装就是：成员变量私有化
提供公共的getter和setter给外界去访问成员变量
#include <iostream>
using namespace std;
struct Person{
private:
int m_age;
public:
void setAge(int age) {
if (age < 0) return;
m_age = age;
}
int getAge() {
return m_age;
}
};
int main() {
Person person;
person.setAge(4);
cout << person.getAge() << endl;
return 0;
}
输出结果：4
5. 内存空间的布局
每个内存都应有自己独立的内存空间，其内存空间一般都有以下几大区域
5.1 代码段（代码区）
用于存放代码（机器码），只读
5.2 数据段（全局区）
用于存放全局变量等（static）
整个程序运行中都存在，除非关闭进程
#include <iostream>
using namespace std;
//全局变量
int g_age = 10;
int main() {
return 0;
}
g_age 就是全局变量
5.3 栈空间
每调用一个函数就会给它分配一段连续的栈空间，等函数调用完毕后会自动回收这段栈空间（注意：如果申请了堆空间，堆空间需要手动销毁）
#include <iostream>
using namespace std;
int g_age = 10;
// 调用test 开辟连续的栈空间
void test() {
int a = 1;
int b = 2;
int c = a + b;
}
int main() {
// 调用时自动分配，调用后自动回收
test();
return 0;
}
5.4 堆空间
5.4.1 使用场景
在程序运行过程，为了能够自由控制内存的生命周期、大小会经常使用堆空间的内存
5.4.2 需要主动去申请和释放
malloc \ free
new \ delete
new [ ] \ delete [ ]
5.4.3 x86环境（32bit）剖析 malloc
1）malloc
malloc 向堆空间申请内存，因为返回值为void *，需要根据类型强制转换
malloc 只是单纯的向堆空间申请内存，和栈空间的指针类型没关系
free 只看malloc了多少，不能少回收，不会多回收，malloc(n) => free(n)
如下代码：
int为4个字节，刚好等于malloc（4）的大小
#include <iostream>
using namespace std;
int main() {
int* p = (int *)malloc(4);
*p = 10;
free(p);
//free(p); 不要多次回收，一次malloc 一次free
return 0;
}
如下代码：
char 为1个字节，而malloc（4）为4个字节的大小
#include <iostream>
using namespace std;
int main() {
char* p = (char*)malloc(4);
*p = '1';
*(p+1) = '2';
*(p+2) = '3';
*(p+3) = '4';
/*
p[0] = '1';
p[1] ='2';
p[2] ='3';
p[3] ='4';
*/
cout << *(p) << endl;
cout << *(p + 1) << endl;
cout << *(p + 2) << endl;
cout << *(p + 3) << endl;
free(p);
return 0;
}
*(p+1) = ‘2’; 等价于 p[1] =‘2’;
此时 free§; 销毁的为4个字节（因为malloc(4)），不会因为char是一个字节，只回收一个字节
5.4.4 new \ delete
new 和 delete 的一一对应关系
void test2() {
int* p = new int; // 等价于 (int*)malloc(4);
*p = 10;
delete p;
char* p1 = new char;// 等价于 (char*)malloc(1); 因为char占1个字节
*p1 = '10';
delete p1;
char* p2 = new char[4];// 等价于 (char*)malloc(4);
delete[] p2;
}
delete 只会销毁指针指向的堆空间的内存，不会删除 指针的地址（内容）
在下一章《单例模式》中会进一步说明
5.4.5 memset 较大数据处理函数
1）memset(首地址, 要赋的值,长度);
2）memset 是将每一个字节赋值
void test3() {
int* p1 = (int*)malloc(sizeof(int));// *p1未初始化
int* p2 = (int*)malloc(sizeof(int));
//初始化的2种情况
// 从p1 地址开始，将4个字节中的每一个字节都设置为1
// 00000001 00000001 00000001 00000001
memset(p2, 1, 4);
//将4个字节设置为1
// 00000000 00000000 00000000 00000001
}
3）memset 函数是将较大的数据结构（比如对象、数组等）内存清零的比较快的方法
4）对象初始化
构造函数
struct Person {
int m_age;
Person() {
memset(this, 0, sizeof(Person));
}
};
5.4.6 堆空间的初始化
int* p0 = new int;
int* p1 = new int(); // 有小括号的会初始化 （不使用memset的初始化 ）
int* p2 = new int(5);// 有小括号的会初始化（不使用memset的初始化 ）
如下代码：
可以看出被初始化的是将4个字节设置为5（这里不是用的memset）
这里 -842150451 对应内存为 cd cd cd cd
5.4.7 结论
1） 申请堆空间成功后，会返回那一段内存空间的地址
2） 申请和释放必须是1对1的关系，不然可能会存在内存泄露
3） 管理内存->利：提高开发效率，避免内存使用不当或泄露
4） 管理内存->弊：不利于开发人员了解本质，永远停留在API调用和表层语法糖，对性能优化无从下手
6. 对象的内存
6.1 对象的内存可以存放在3个地方
6.1.1 全局区（数据段）：全局变量
6.1.2 栈空间：函数里面的局部变量
栈空间对象初始化时，成员变量默认为 cc cc cc cc
所以：person.m_age 报错
6.1.3 堆空间：动态申请内存（malloc、new等）
7. 构造函数（Constructor）
构造函数（构造器）：在对象创建的时候自动调用，一般用于完成对象的初始化工作
构造函数私有化：可以类不可访问（不可创建对象）
7.1 引入构造函数的使用场景
#include <iostream>
using namespace std;
struct Person{
int m_age;
};
int main() {
//引入构造函数的场景
Person person;
person.m_age = 0;
// 创建多个对象时，需要给每一个成员变量初始值
Person person1;
person1.m_age = 0;
Person person2;
person2.m_age = 0;
Person person3;
person3.m_age = 0;
return 0;
}
7.2 特点
7.2.1 函数名与类同名，无返回值（void不能写），可以有参数，可以重载，可以有多个构造函数
7.2.2 一旦自定义了构造函数，必须用其中一个自定义的构造函数来初始化对象
1）验证：一旦自定义了构造函数，必须用其中一个
#include <iostream>
using namespace std;
struct Person{
int m_age;
Person() {
m_age = 0;
cout << "Person()" << endl;
}
Person(int age) {
m_age = age;
cout << "Person(int age)" << m_age<< endl;
}
void display() {
cout << "age is " << m_age << endl;
}
};
int main() {
Person person1; // 使用构造函数 Person()
person1.display();
Person person2(20);// 使用构造函数 Person(int age)
person2.display();
Person person3(30);// 使用构造函数 Person(int age)
person3.display();
return 0;
}
输出结果：
Person()
age is 0
Person(int age)20
age is 20
Person(int age)30
age is 30
如下代码：违反了自定义函数必须使用其一的原则
纠正图片错误：“午餐”=》“无参”
7.3 通过malloc分配的对象不会调用构造函数
7.3.1 不要用malloc搞对象（要去new）
malloc 从C语言沿用过来，C语言本身没有面向对象的概念，所以不会调用构造函数
#include <iostream>
using namespace std;
struct Person{
int m_age;
Person(int age) {
m_age = age;
cout << "Person::Person(int age)-" << m_age<< endl;
}
void display() {
cout << "Person::display()-" << m_age << endl;
}
};
int main() {
Person* p = (Person*)malloc(sizeof(Person));
p->m_age = 44;
p->display();
return 0;
}
7.4 构造函数的谬论
7.4.1 一个广为流传的、很多教程、书籍都推崇的错误结论
默认情况下，编译器会为每一个类生成空的无参的构造函数
1）先来看一下有构造函数的反汇编
2）再来看一下没有构造函数的反汇编
根本没有调用 call Person::Person(地址) 这句汇编语言
7.4.2 谬论的正确理解
在某些特殊情况下，编译器才会为类生成空的无参的构造函数
7.5 构造函数的调用
7.5.1 全局区、栈空间、堆空间 创建对象时构造函数的调用
#include <iostream>
using namespace std;
struct Person {
int m_age;
Person() {
m_age = 0;
cout << "Person()" << endl;
}
Person(int age) {
m_age = age;
cout << "Person(int age)" << endl;
}
};
Person g_person0;// Person()
//Person g_person1(); 函数声明,没有创建对象 // 直接报错
Person g_person2(10);// Person(int)
int main() {
Person person0;// Person()
Person person1();// 函数声明,没有创建对象
Person person2(20);// Person(int)
Person* p0 = new Person;// Person()
Person* p1 = new Person();// Person()
Person* p2 = new Person(30);// Person(int)
return 0;
}
1）Person person() 这种写法不是创建对象 的写法，无论在全局区、栈空间
2）Person person() 这种写法都为函数声明（详见C++ 函数声明与实现）
8. 成员变量的初始化
8.1 全局区、栈空间、堆空间，无构造函数时 初始化成员变量区别
如下代码：
#include <iostream>
using namespace std;
struct Person {
int m_age;
};
//全局区：成员变量初始化为0
Person g_person;
int main() {
//栈空间：没有初始化成员变量
Person person;
//堆空间：没有初始化成员变量
Person* p0 = new Person;// Person()
//堆空间：成员变量初始化为0
Person* p1 = new Person();// Person()
cout << g_person.m_age << endl;
//cout << person.m_age << endl;
cout << p0->m_age << endl;
cout << p1->m_age << endl;
return 0;
}
输出：
0
-842150451
0
8.1.1 全局区：成员变量初始化为0（int类型）
8.1.2 栈空间：没有初始化成员变量
（可见：6.1.2 栈空间：函数里面的局部变量）
8.1.3 堆空间
//堆空间：没有初始化成员变量
Person* p0 = new Person;// Person()
//堆空间：成员变量初始化为0
Person* p1 = new Person();// Person()
8.2 全局区、栈空间、堆空间，有构造函数时 初始化成员变量区别
#include <iostream>
using namespace std;
struct Person {
int m_age;
Person() {
}
};
//全局区：成员变量初始化为0
Person g_person;
int main() {
//栈空间：没有初始化成员变量
Person person;
//堆空间：没有初始化成员变量
Person* p0 = new Person;// Person()
//堆空间：成员变量初始化为0
Person* p1 = new Person();// Person()
cout << g_person.m_age << endl;
//cout << person.m_age << endl;
cout << p0->m_age << endl;
cout << p1->m_age << endl;
return 0;
}
输出：
0
-842150451
-842150451
8.2.1 全局区：成员变量初始化为0（int类型）
有无构造函数不影响全局区
内存空间的一个特点
8.2.2 栈空间：没有初始化成员变量
（可见：6.1.2 栈空间：函数里面的局部变量）
8.2.3 堆空间
因为自定义构造函数，堆空间不再初始化对象。成员变量完全由构造函数决定
8.3 结论
如果自定义了构造函数，除了全局区，其他内存空间的成员变量默认都不会被初始化，需要开发人员手动初始化
9. 析构函数（Destructor）
析构函数（析构器）：在对象销毁的时候自动调用，一般用于完成（堆空间）对象的清理工作
9.1 引入析构函数的使用场景
当对象被销毁（回收）自动调用
#include <iostream>
using namespace std;
struct Person {
int m_age;
//新的 person 对象诞生的象征
Person() {
cout << "Person:;Person()" << endl;
}
//新的 person 对象销毁（回收）的象征
~Person() {
cout << "~Person" << endl;
}
};
int main() {
Person person;
return 0;
}
9.2 特点
函数名以~开头，与类同名，无返回值（void都不能写），无参，不可以重载，有且只有一个析构函数（总共6点）
9.2.1 函数与析构函数
如下代码：
#include <iostream>
using namespace std;
struct Person {
int m_age;
//新的 person 对象诞生的象征
Person() {
cout << "Person:;Person()" << endl;
}
//新的 person 对象销毁（回收）的象征
~Person() {
cout << "~Person" << endl;
}
};
int main() {
{
Person person;
}
return 0;
}
运行结果
9.2.2 指针与析构函数
如下代码：
#include <iostream>
using namespace std;
struct Person {
int m_age;
//新的 person 对象诞生的象征
Person() {
cout << "Person:;Person()" << endl;
}
//新的 person 对象销毁（回收）的象征
~Person() {
cout << "~Person" << endl;
}
};
int main() {
Person*p =new Person;
delete p;
return 0;
}
运行结果
9.3 malloc 与 free 无关 构造函数与析构函数
通过malloc分配的对象free的时候不会调用析构函数
如下代码：
#include <iostream>
using namespace std;
struct Person {
int m_age;
//新的 person 对象诞生的象征
Person() {
cout << "Person:;Person()" << endl;
}
//新的 person 对象销毁（回收）的象征
~Person() {
cout << "~Person" << endl;
}
};
int main() {
Person* p = (Person*)malloc(sizeof(Person));
free(p);
return 0;
}
运行结果
9.4 全局区与析构函数
只要程序还在运行，就无法看到析构函数，除非杀死进程停止程序
结论：全局区不会看到析构函数的调用
9.4 构造与析构函数必须为public
构造函数和析构函数都要声明为public，才能被外界使用
class Person {
int m_age;
public:
//新的 person 对象诞生的象征
Person() {
cout << "Person:;Person()" << endl;
}
//新的 person 对象销毁（回收）的象征
~Person() {
cout << "~Person" << endl;
}
};
