第41篇 C++类与对象核心知识梳理：从底层原理到面试实战

目录

一、类的定义

[1.1 类定义格式与细节](#1.1 类定义格式与细节)

[1.2 访问限定符与封装](#1.2 访问限定符与封装)

[1.3 类域与作用域操作符](#1.3 类域与作用域操作符)

二、类的实例化

[2.1 实例化概念与设计图类比](#2.1 实例化概念与设计图类比)

[2.2 对象大小与内存对齐规则](#2.2 对象大小与内存对齐规则)

三、this指针深度解析

[3.1 this指针的本质与真实原型](#3.1 this指针的本质与真实原型)

[3.2 this指针的存储位置](#3.2 this指针的存储位置)

[3.3 经典面试题：空指针调用成员函数](#3.3 经典面试题：空指针调用成员函数)

四、C与C++实现Stack对比

---

一、类的定义

1.1 类定义格式与细节

关于类的定义，最基础的是掌握class关键字的使用。在C++中，class后面跟着类名，大括号{}内是类的主体，里面包含的成员变量（属性）和成员函数（方法）。这里有一个极易踩坑的地方：类定义结束时，大括号后面的分号;绝对不能省略，否则编译器会报错。

为了区分成员变量和局部变量，一般习惯上会在成员变量前或后加一个下划线_，或者以m开头。需要注意的是，C++标准对此并没有强制要求，这纯粹是行业惯例，具体怎么写要看公司的代码规范。

另外，C++兼容了C语言中struct的用法，但对其进行了升级。最明显的变化是struct中也可以定义函数了，而且struct的名称本身就可以代表类型。不过在实际工程中，我们还是推荐用class来定义类。还有一个隐藏知识点：定义在类里面的成员函数，默认是inline（内联）的。

下面是一个包含Init、Push、Top、Destroy成员函数的Stack类示例：

#include<iostream>
using namespace std;
class Stack
{
public:
       // 成员函数
       void Init(int n = 4)
       {
               array = (int*)malloc(sizeof(int) * n);
               if (nullptr == array)
               {
                       perror("malloc申请空间失败");
                       return;
               }
               capacity = n;
               top = 0;
       }
       void Push(int x)
       {
               // ...扩容
               array[top++] = x;
       }
       int Top()
       {
               assert(top > 0);
               return array[top - 1];
       }
       void Destroy()
       {
               free(array);
               array = nullptr;
               top = capacity = 0;
       }
private:
       // 成员变量
       int* array;
       size_t capacity;
       size_t top;
}; // 分号不能省略

int main()
{
       Stack st;
       st.Init();
       st.Push(1);
       st.Push(2);
       cout << st.Top() << endl;
       st.Destroy();
       return 0;
}

再看一个Date类的例子，注意成员变量的命名习惯：

class Date
{
public:
       void Init(int year, int month, int day)
       {
               _year = year;
               _month = month;
               _day = day;
       }
private:
       // 为了区分成员变量，一般习惯上成员变量
       // 会加一个特殊标识，如_ 或者 m开头
       int _year; // year_  m_year
       int _month;
       int _day;
};
int main()
{
       Date d;
       d.Init(2024, 3, 31);
       return 0;
}

关于C++中struct的升级，这里给一个对比示例：

#include<iostream>
using namespace std;
// C++升级struct升级成了类
// 1、类里面可以定义函数
// 2、struct名称就可以代表类型
// C++兼容C中struct的用法
typedef struct ListNodeC
{
       struct ListNodeC* next;
       int val;
}LTNode;
// 不再需要typedef，ListNodeCPP就可以代表类型
struct ListNodeCPP
{
       void Init(int x)
       {
               next = nullptr;
               val = x;
       }
       ListNodeCPP* next;
       int val;
};

1.2 访问限定符与封装

C++实现封装的核心手段之一就是访问限定符。通过class将对象的属性和方法结合在一起，同时利用访问权限，选择性地将接口暴露给外部用户。

• public修饰的成员在类外可以直接被访问。
• protected和private修饰的成员在类外不能直接被访问。在当前阶段，这两者的表现是一样的，它们的区别要等到后续学习继承时才能体现出来。
• 访问权限的作用域从该限定符出现的位置开始，直到下一个限定符出现为止；如果后面没有其他限定符，作用域一直延伸到类结束的}。
• class定义的成员如果没有被限定符修饰，默认是private；而struct默认是public。
• 在实际开发中，一般会把成员变量限制为private或protected，而把需要给外部调用的成员函数设为public。

1.3 类域与作用域操作符

类定义了一个新的作用域，所有成员都在这个类的作用域中。当我们在类体外定义成员函数时，必须使用::作用域操作符来指明该成员属于哪个类。

这里有一个很容易踩坑的地方：如果不指定类域，编译器会把函数当成全局函数。比如Init如果不加上Stack::，编译时编译器在当前域找不到array等成员的声明，就会直接报错。指定了Stack::后，编译器就知道Init是成员函数，当前域找不到时，就会去类域中查找。

声明和定义分离的代码示例：

#include<iostream>
using namespace std;
class Stack
{
public:
   // 成员函数
   void Init(int n = 4);
private:
   // 成员变量
   int* array;
   size_t capacity;
   size_t top;
};
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
   array = (int*)malloc(sizeof(int) * n);
   if (nullptr == array)
   {
       perror("malloc申请空间失败");
       return;
   }
   capacity = n;
   top = 0;
}
int main()
{
   Stack st;
   st.Init();
   return 0;
}

二、类的实例化

2.1 实例化概念与设计图类比

用类类型在物理内存中创建对象的过程，称为类的实例化。

关于这个概念，我的理解是：类只是一个抽象的模型（类似于建筑设计图），它限定了有哪些成员变量，但此时并没有分配物理空间。只有用类实例化出对象时，才会在内存中真正分配空间。一个类可以实例化出多个对象，每个对象都有独立的物理空间来存储数据。打个比方，类就像设计图，规划了房间的大小和功能，但不能住人；用设计图建出房子后，房子才能住人。同样，类不能直接存储数据，实例化出的对象才能分配物理内存存储数据。

Date类实例化示例：

#include<iostream>
using namespace std;
class Date
{
public:
   void Init(int year, int month, int day)
   {
       _year = year;
       _month = month;
       _day = day;
   }
   void Print()
   {
       cout << _year << "/" << _month << "/" << _day << endl;
   }
private:
   // 这里只是声明，没有开空间
   int _year;
   int _month;
   int _day;
};
int main()
{
   // Date类实例化出对象d1和d2
   Date d1;
   Date d2;
   d1.Init(2024, 3, 31);
   d1.Print();
   d2.Init(2024, 7, 5);
   d2.Print();
   return 0;
}

2.2 对象大小与内存对齐规则

面试的时候如果问到对象大小怎么算，可以从这几个角度回答：

首先，类实例化出的每个对象都有独立的数据空间，所以对象中肯定包含成员变量。那成员函数呢？函数被编译后是一段指令，存储在代码段，对象中没办法存储指令。如果非要存，只能存成员函数的指针。但是，像d1和d2这样的对象，它们的成员函数Init和Print的代码地址是一样的，如果在每个对象里都存一份指针，实例化100个对象就重复存了100次，太浪费了。

其实函数指针是不需要存储在对象中的。函数调用在编译链接时就已经确定了地址（汇编指令call 地址），只有在动态多态（虚函数）时才需要在运行时查找地址。所以，对象中只存储成员变量，并且必须符合内存对齐规则。

内存对齐的核心规则：

• 第一个成员在与结构体偏移量为0的地址处。
• 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认对齐数与该成员大小的较小值（VS中默认对齐数为8）。
• 结构体总大小为最大对齐数的整数倍。
• 如果嵌套了结构体，嵌套的结构体对齐到自己的最大对齐数的整数倍处，整体大小是所有最大对齐数（含嵌套结构体）的整数倍。

计算对象大小的代码示例：

#include<iostream>
using namespace std;
// 计算一下A/B/C实例化的对象是多大？
class A
{
public:
   void Print()
   {
       cout << _ch << endl;
   }
private:
   char _ch;
   int _i;
};
class B
{
public:
   void Print()
   {
       //...
   }
};
class C
{};
int main()
{
   A a;
   B b;
   C c;
   cout << sizeof(a) << endl;
   cout << sizeof(b) << endl;
   cout << sizeof(c) << endl;
   return 0;
}

运行上面的程序会发现，没有成员变量的B和C类对象大小是1。为什么没有成员变量还要给1个字节？因为如果一个字节都不给，怎么表示对象存在过呢！这1个字节纯粹是为了占位，标识对象的存在。

三、this指针深度解析

3.1 this指针的本质与真实原型

我自己之前对成员函数如何区分不同对象一直不太理解，后来发现关键在于C++提供的隐含this指针。

比如Date类中有Init和Print，函数体里并没有区分对象的代码。当d1调用它们时，编译器在编译后，默认会在成员函数的形参第一个位置增加一个当前类类型的指针，这就是this指针。也就是说，Date::Init的真实原型其实是：void Init(Date* const this, int year, int month, int day)。

在成员函数中访问成员变量，本质上都是通过this指针访问的，比如_year = year;实际上被编译器处理成了this->_year = year;。

需要注意的是，C++规定不能在实参和形参的位置显式写this指针（编译器会自动处理），但可以在函数体内显式使用。

代码示例：

#include<iostream>
using namespace std;
class Date
{
public:
   // void Init(Date* const this, int year, int month, int day)
   void Init(int year, int month, int day)
   {
       // 编译报错：error C2106: "=": 左操作数必须为左值
       // this = nullptr;
       // this->_year = year;
       _year = year;
       this->_month = month;
       this->_day = day;
   }
   void Print()
   {
       cout << _year << "/" << _month << "/" << _day << endl;
   }
private:
   // 这里只是声明，没有开空间
   int _year;
   int _month;
   int _day;
};
int main()
{
   // Date类实例化出对象d1和d2
   Date d1;
   Date d2;
   // d1.Init(&d1, 2024, 3, 31);
   d1.Init(2024, 3, 31);
   d1.Print();
   d2.Init(2024, 7, 5);
   d2.Print();
   return 0;
}

3.2 this指针的存储位置

关于this指针存在内存哪个区域，答案是栈。因为this指针本质上是函数的隐藏参数，而函数参数都是存放在栈上的。

3.3 经典面试题：空指针调用成员函数

这两道选择题在面试和笔试中出场率高，核心考察的就是对this指针的理解：

题目1：

#include<iostream>
using namespace std;
class A
{
public:
   void Print()
   {
       cout << "A::Print()" << endl;
   }
private:
   int _a;
};
int main()
{
   A* p = nullptr;
   p->Print();
   return 0;
}

答案：正常运行。 因为Print()函数内部没有访问任何成员变量，不需要对this指针进行解引用操作，所以即使p是空指针也不会崩溃。

题目2：

#include<iostream>
using namespace std;
class A
{
public:
   void Print()
   {
       cout << "A::Print()" << endl;
       cout << _a << endl;
   }
private:
   int _a;
};
int main()
{
   A* p = nullptr;
   p->Print();
   return 0;
}

答案：运行崩溃。 因为Print()中访问了成员变量_a，编译器会将其转换为this->_a。此时this指针为nullptr，对其进行解引用访问内存，必然导致程序崩溃。

四、C与C++实现Stack对比

将C语言的Stack实现迁移到C++，能非常直观地体会到面向对象的优势。

C++中数据和函数都放到了类里面，通过访问限定符进行了限制，不能再随意通过对象直接修改内部数据。这是C++封装的最直接体现，其本质是一种更严格规范的管理，避免了外部乱访问、乱修改导致的数据安全问题。

除了封装，C++在语法上也方便了很多：

• Init函数可以使用缺省参数，省去了每次都要传容量的麻烦。
• 成员函数每次不需要手动传对象地址，因为this指针是隐含传递的。
• 使用类型不再需要typedef，直接用类名即可。

C实现Stack代码：

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
   STDataType* a;
   int top;
   int capacity;
}ST;
void STInit(ST* ps)
{
   assert(ps);
   ps->a = NULL;
   ps->top = 0;
   ps->capacity = 0;
}
void STDestroy(ST* ps)
{
   assert(ps);
   free(ps->a);
   ps->a = NULL;
   ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
   assert(ps);
   // 满了， 扩容
   if (ps->top == ps->capacity)
   {
       int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
       STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
       if (tmp == NULL)
       {
           perror("realloc fail");
           return;
       }
       ps->a = tmp;
       ps->capacity = newcapacity;
   }
   ps->a[ps->top] = x;
   ps->top++;
}
bool STEmpty(ST* ps)
{
   assert(ps);
   return ps->top == 0;
}
void STPop(ST* ps)
{
   assert(ps);
   assert(!STEmpty(ps));
   ps->top--;
}
STDataType STTop(ST* ps)
{
   assert(ps);
   assert(!STEmpty(ps));
   return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
   assert(ps);
   return ps->top;
}
int main()
{
   ST s;
   STInit(&s);
   STPush(&s, 1);
   STPush(&s, 2);
   STPush(&s, 3);
   STPush(&s, 4);
   while (!STEmpty(&s))
   {
       printf("%d\n", STTop(&s));
       STPop(&s);
   }
   STDestroy(&s);
   return 0;
}

C++实现Stack代码：

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
   // 成员函数
   void Init(int n = 4)
   {
       _a = (STDataType*)malloc(sizeof(STDataType) * n);
       if (nullptr == _a)
       {
           perror("malloc申请空间失败");
           return;
       }
       _capacity = n;
       _top = 0;
   }
   void Push(STDataType x)
   {
       if (_top == _capacity)
       {
           int newcapacity = _capacity * 2;
           STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
           if (tmp == NULL)
           {
               perror("realloc fail");
               return;
           }
           _a = tmp;
           _capacity = newcapacity;
       }
       _a[_top++] = x;
   }
   void Pop()
   {
       assert(_top > 0);
       --_top;
   }
   bool Empty()
   {
       return _top == 0;
   }
   int Top()
   {
       assert(_top > 0);
       return _a[_top - 1];
   }
   void Destroy()
   {
       free(_a);
       _a = nullptr;
       _top = _capacity = 0;
   }
private:
   // 成员变量
   STDataType* _a;
   size_t _capacity;
   size_t _top;
};
int main()
{
   Stack s;
   s.Init();
   s.Push(1);
   s.Push(2);
   s.Push(3);
   s.Push(4);
   while (!s.Empty())
   {
       printf("%d\n", s.Top());
       s.Pop();
   }
   s.Destroy();
   return 0;
}