你好，我是安然无虞。 |
文章目录
- 结构体传参
- this指针
- 大厂面试真题
自学网站
写在前面
前面的C++入门知识已经讲解完毕了，重难点部分需要及时消化哦，现在我们开始类和对象的学习，老铁请放心，这部分内容虽然有点多，也属于重点，但是不算太难，跟着我肯定都能掌握的，加油吧少年们。
面向过程和面向对象的初步认识
我们知道C语言是面向过程的，关注点在于过程，分析出求解问题的步骤，通过函数调用逐步解决问题；
C++是面向对象的，关注点在于对象，将一件事拆分成不同的对象，靠对象之间的交互完成。
就好比我们生活中的外卖系统：
用面向过程来说就是：上架货品、点外卖、通知商家、分配骑手、派送、点评等，注重的是过程本身；而用面向对象来说就是：商家、用户和骑手，注重的是对象本身。
类的引入
C语言中，结构体内只能定义变量，不过在C++中，结构体内不仅可以定义变量，还可以定义函数。
struct Student
{
void SetStudent(const char* name, const char* gender, int age)
{
strcpy(_name, name);
strcpy(_gender, gender);
_age = age;
}
void PrintStudent()
{
cout << _name << " " << _gender << " " << _age << endl;
}
char _name[20];
char _gender[3];//性别
int _age;
};
int main()
{
Student s;
s.SetStudent("sl", "男", 21);
s.PrintStudent();
return 0;
}
上面结构体的定义，C语言用的是struct，C++用 struct 和 class 都可以，但是C++更喜欢用 class 来代替 struct。因为C++兼容C语言 struct 的用法，C++同时对struct进行了升级，把struct升级成了类。什么是类呢，它有如下两个特点：
- 结构体名称可以做类型；
- 类里面可以定义函数
struct ListNode//用struct和class都可以，C++更喜欢用class
{
int val;
struct ListNode* next;
//现在的写法
ListNode* next;//类名可以直接做类型
};
类的定义
class className
{
//类体：由成员函数和成员变量组成
};//一定要注意后面的分号
class为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束时后面的分号。
类中的元素称为类的成员：类中的数据称为类的属性或者成员变量；类中的函数称为类的方法或者成员函数。
类的两种定义方式：
1、声明和定义全部放在类体中，需要注意：成员函数在类中定义，编译器可能会将其当成内联函数处理，所以一般情况下，短小函数可以直接在类里面定义，长一点的函数声明和定义分离；
可能这时候有的老铁会想到C++入门，那时候讲到内联函数声明和定义不能分离，否则会导致链接错误这个问题。同样的，如果函数比较长，这时候还在类中定义，类又在.h头文件中实现，在其他两个.cpp源文件中展开这个.h文件，会不会出现链接错误（重定义）呢？
答案是不会，因为类中如果定义较长的函数，虽然不会当作内联函数处理，但是它的定义、地址都已经知道了，编译器不会将它再放到符号表中，所以链接的时候不用去符号表中找。（这个的话了解一下即可）
class Person
{
public:
//显示基本信息
void PrintPerson()
{
cout << _name << " " << _gender << " " << _age << endl;
}
public:
char* _name;
char* _gender;//性别
int _age;
};
2、声明放在.h文件中，类的定义放在.cpp文件中。
//声明放到类的头文件person.h中
class Person
{
public:
void PrintPerson();
public:
char* _name;
char* _gender;
int _age;
};
//定义放到类的实现文件person.cpp中
#include"person.h"
void Person::PrintPerson()//需要指定类域
{
cout << _name << " " << _gender << " " << _age << endl;
}
一般情况下，更期望采用第二种方式。
类的访问限定符及封装
访问限定符
C++实现封装的方式：用类将对象的属性和方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
访问限定符说明：
- public 修饰的成员在类外可以直接被访问；
- protected 和 private 修饰的成员在类外不能直接被访问；（现阶段我们暂且认为 protected 和 private 一样，等到继承时再区分）
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止；
- class 的默认访问权限是 private，struct 的默认访问权限是 public。（因为 struct 要兼容C语言）
注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。
面试题
问题：C++中 struct 和 class 的区别是什么？
解答：C++需要兼容C语言，所以C++中 struct 可以当成结构体去使用，另外C++中 struct 还可以用来定义类，和 class 定义类是一样的，区别在于 struct 的成员默认访问方式是 public，class 的成员默认访问方式是 private。
封装
【面试题】
面向对象的三大特性：封装、继承、多态。
在类和对象阶段，我们只研究了类的封装特性，那什么是封装呢？
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理：为什么这么说呢，比如现实生活中我们如何管理兵马俑的？如果什么都不管，兵马俑肯定被随意破坏了，所以我们首先要建一座房子把兵马俑给封装起来，但还要给别人看到，不能全封装起来，所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。
类也是这样，我们使用类中的数据和方法都封装到了一起，不想让别人看到，使用 protected/private 把成员封装起来，开放一些共有的成员函数对成员进行合理的访问。所以说封装本质上是一种管理。
就拿我们之前学习过的栈这个数据结构来说明这个问题。我们之前是使用C语言来实现栈Stack这个数据结构的，因为C语言数据和方法是分离的，所以我们之前的代码往往都是这样的：
struct Stack
{
int* _a;
int _top;
int _capacity;
};
void StackInit(struct Stack* ps)
{
ps->_a = NULL;
ps->_top = 0;//或者ps->_top = -1;定义很灵活
ps->_capacity = 0;
}
void StackPush(struct Stack* ps, int x)
{}
int StackTop(struct Stack* ps)
{}
int main()
{
struct Stack st;
StackInit(&st);
StackPush(&st, 1);
StackPush(&st, 2);
printf("%d\n", StackTop(&st));
//因为数据和方法是分离的，所以还可能存在这两种写法，但是极容易出错
printf("%d\n", st._a[st._top]);
printf("%d\n", st._a[st._top - 1]);
return 0;
}
如上，用C语言代码实现Stack时，访问栈顶数据时很容易出现错误，因为它的数据和方法是分离的。这样的话就凸显出了C++的优势：
- 数据和方法封装到一起，在类里面；
- 想给你自由访问的设计成公有，不想给你直接访问的设计成私有/保护，一般情况设计类，成员数据都是私有/保护。
用C++代码实现Stack是这样的：
class Stack
{
public:
void Init()
{}
void Push(int x)
{}
int Top()
{}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st;
st.Init();
st.Push(1);
st.Push(2);
printf("%d\n", st.Top());
//printf("%d\n", st._a[st._top]);直接报错，编译通不过
return 0;
}
这里的话老铁能体会到C语言和C++对于栈顶元素的访问方式不同之处就好，具体细节我后面会详细说明哦。
类的作用域
类定义了一个新的作用域，叫类域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符指定成员属于哪个类域。
//person.h文件
class Person
{
public:
void PrintPerson()
{}
private:
char _name[20];
char _gender[3];
int _age;
}
//person.cpp文件
//这里需要指定PrintPerson()属于person这个类域
//访问限定符限制的是在类外进行访问，在类里面不受限制
void person::PrintPerson()
{
cout << _name << " " << _gender << " " << _age << endl;
}
类的实例化
用类类型创建对象的过程，称之为类的实例化。
- 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配出实际的内存空间来存储它；
- 一个类可以实例化出多个对象，实例化处的对象占用实际的物理空间，存储类成员变量；
- 打个比方，类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化处的对象才能实际存储数据，占用物理空间。
请问：类体中的成员变量是声明还是定义，如果是声明，那什么时候定义呢？
答案是声明，那变量的声明和定义的区别是什么呢？区别在于有没有开辟空间。打个比方，你要买房，问朋友借5W块，你朋友答应借给你5W块，这就好比声明，支付宝到账5W块，就好比定义。
既然类体中的成员变量是声明，那什么时候定义呢？答案是在创建对象的时候定义，也就是这一行代码：
Person man;
类对象模型
如何计算类对象的大小？
class A
{
public:
void PrintA()
{
cout << _a << endl;
}
private:
char _a;
};
问题：类中既可以有成员变量，有可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小？
若要解决这个问题，需要继续向下学习。
类对象的存储方式猜测
猜测1：对象中包含类的各个成员
缺陷：每个对象中成员变量是不同的，却是调用同一份成员函数，如果按照这种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。
比如还是之前的Stack代码：
st1调用Init()，st2调用Init()是不是同一个Init()，是的，是同一个Init()，有没有必要把成员函数在对象里面都存一份，答案是没有必要，因为不同的对象调用的是同一个函数，通过汇编代码就能看出来。
那么该如何解决呢？猜测2：只保存成员变量，成员函数放在公共代码段
所以下面代码的意义不一样：
Stack st1;
st1._top;//_top在st1里面找
st1.Init();//调用Init()不是在对象里面找，而是到公共代码段中
问题：对于上述两种存储方式，计算机到底是按照哪种方式来存储的？
我们通过对下面的不同对象分别获取大小来分析：
//类中既有成员变量，又有成员函数
class A1
{
public:
void f1()
{}
private:
char _ch;
int _a;
};
//类中仅有成员函数
class A2
{
public:
void f2()
{}
};
//类中什么都没有，空类
class A3
{};
int main()
{
cout << sizeof(A1) << endl;//8
cout << sizeof(A2) << endl;//1
cout << sizeof(A3) << endl;//1
return 0;
}
可以认为sizeof(A1)和sizeof(A2)一样大，因为成员函数不在对象里面。可有老铁会问了，既然成员函数不再对象里面，为什么大小不是0，而且空类的大小也不是0？
可以这样解释：如果大小是0，那么A2类型定义对象aa时：
A2 aa;
cout << &a << endl;
aa的地址是多少呢？所以这1个字节不是为了存储有效数据，而是为了表示对象存在过。
总结：一个类的大小，实际就是该类中“成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类1个字节来唯一标识这个类，没有成员变量的类对象，编译器会给他们分配1个字节用于表示对象存在过。
结构体内存对齐规则
现在我们深入探讨一个问题：计算结构体的大小。这也是一个特别热门的考点：结构体内存对齐。
学过C语言的老铁快来检测自己吧。
练习1：
struct s1
{
char c1;
int i;
char c2;
};
printf("%d\n", sizeof(struct s1));
练习2：
struct s2
{
char c1;
char c2;
int i;
};
printf("%d\n", sizeof(struct s2));
练习3：
struct s3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct s3));
练习4：结构体嵌套问题
struct s3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct s3));
struct s4
{
char c1;
struct s3 s;
double d;
};
printf("%d\n", sizeof(struct s4));
OK，请老铁结合下面的方法计算。
那么如何计算结构体的大小呢？
首先得掌握结构体的对齐规则：
- 第一个成员在与结构体变量偏移量为0的地址处；
- 其他成员要对齐到某个数字（对齐数）的整数倍的地址处；对齐数 = 编译器默认的一个对齐数与该成员大小的较小值（VS默认对齐数是8）
- 结构体的总大小为最大对齐数（每个成员变量都有自己的对齐数）的整数倍；
- 如果是嵌套了结构体的情况，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
注意：
关于默认对齐数的概念，在VS下默认是8，在Linux下没有默认对齐数的概念，对齐数就是成员自身的大小。
这里可能就有老铁会问了，为什么要存在内存对齐呢？
基本上有两点原因：
1、平台原因（移植原因）
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、性能原因
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问，而对齐的内存访问时近一次即可。
总体来说：
结构体的内存对齐是拿空间换时间的做法。
请看下面：
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有一些的区别。
结构体传参
struct S
{
int data[1000];
int num;
};
struct S s = {{1,2,3,4}, 1000};
//结构体传参
void print1(struct S s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址
return 0;
}
上面的 print1 和 print2 函数哪个好些？
答案是print2函数好些。
原因：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
this指针
this指针的引出
我们先来定义一个日期类Date：
class Date
{
public:
void SetDate(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Display()
{
cout << _year << " " << _month << " " << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1, d2;
d1.SetDate(2022, 8, 24);
d2.SetDate(2022, 9, 3);
d1.Display();
d2.Display();
return 0;
}
通过汇编代码可以看到d1和d2调用的是同一个Display()，那为什么打印的值不一样呢？
聪明的老铁很快就能想到this指针，没错，调用成员函数Display()的地方会编译器被处理成：
d1.Display(&d1);
d2.Display(&d2);
同样的，Display()也会被编译器隐含的处理成这个样子：
void Display(Date* const this)//this指针不可以修改
{
cout << this->_year << " " << this->_month << " " << this->_day << endl;
}
形参和实参部分不能显示的写出来，因为是编译器隐含的处理的，我们不能抢了编译器的饭碗。
this指针的特性
1、this指针的类型：类类型* const；
2、只能在成员函数的内部使用；（注意）
3、this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参，所以对象中不存储this指针；
4、this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
大厂面试真题
1、下面程序编译运行结果是什么？
A.编译报错
B.运行崩溃
C.正常运行
class A
{
public:
void show()
{
cout << "show()" << endl;
}
public:
int _a;
};
int main()
{
A* p = nullptr;
p->show();
p->_a;
return 0;
}
解答：这道题打死都不能选编译报错，因为编译时是查不出空指针错误的，所有的空指针、野指针问题都是在运行时暴露出来的。
这道题的答案是正常运行，为什么没有崩溃呢？下面我们看调试后的汇编代码：
p->show();//对象里面只有成员变量，所以并没有解引用，而是调用这个函数
那这行代码为什么没有崩溃呢？
p->_a;
从汇编代码中你就能发现，编译器优化后直接跳过这行代码什么都没做，但是如果将代码改成这样子就会运行崩溃了：
class A
{
public:
void show()
{
cout << "show()" << endl;
}
public:
int _a;
};
int main()
{
A* p = nullptr;
p->show();
p->_a = 10;
return 0;
}
再看看现在的汇编代码：
其实这就发生解引用了，因为不能访问空指针，所以报错，上面的代码之所以没有报错是因为什么都没做，这里不一样。
变形题：
class A
{
public:
void PrintA()
{
//编译器隐含处理成:cout << this->a << endl;
cout << _a << endl;//这道题是在这里崩溃的
}
private:
int _a;
};
int main()
{
A* p = nullptr;
p->PrintA();
return 0;
}
2、this指针存在哪里？
A.栈区
B.堆区
C.静态区
D.常量区
解答：因为this指针是成员函数第一个隐含的指针形参，函数栈帧的创建是需要压栈的，所以很明显，this指针存在于栈区，不过有些编译器会使用寄存器优化存放到寄存器中。