【C++基础】面试题——Day4
欢迎文末添加好友交流，共同进步！
- 目录
- C++ 中 struct 和 class 的区别?
- C++ 中 struct 和 union 的区别？如何使用 union 做优化?
- C++ 中 using 和 typedef 的区别?
- C++ 中 enum 和 enum class 的区别?
- C++ 中 new 和 malloc 的区别？delete 和 free 的区别?
- C++ 中类定义中 delete 关键字和 default 关键字的作用?
- C++ 中 this 指针的作用?
- C++ 中可以使用 delete this 吗?
- C++ 中 vector 的原理？resize 和 reserve 的区别？size 和 capacity 的区别?
- C++ 中 deque 的原理？它内部是如何实现的?
目录
C++ 中 struct 和 class 的区别?
从语法上看只有一处区别，其余都是使用习惯：
- 默认访问权限：
class默认成员是private，struct默认是public。继承时同理——class B : A默认私有继承，struct B : A默认公有继承。 - 使用习惯（不是语法规定）：
struct常用于"plain old data（POD）/ 简单数据聚合"，成员基本公开，少量或没有成员函数。class常用于"封装良好的复杂类型"，成员私有 + 提供接口。
一句话：语法上只差一个"默认 public/private"，习惯上 struct 装数据、class 装逻辑。
C++ 中 struct 和 union 的区别？如何使用 union 做优化?
- struct：每个成员各自独立占用一块内存，对象大小 ≈ 各成员大小之和（考虑内存对齐）。同一时刻可以访问任意成员。
- union：所有成员共享同一块首地址的内存，大小 = 最大成员的大小。同一时刻只能"有效"地保存一个成员（写一个会覆盖另一个）。
struct S { int a; double b; }; // a 和 b 各占各的，sizeof ≈ 16 union U { int a; double b; }; // a 和 b 共用一块，sizeof = 8 U u; u.a = 1; u.b = 3.14; // 写 b 之后 a 已经被覆盖，不能再读 aunion 的优化场景：
- 嵌入式/底层节省内存：多个字段在同一时刻只会用到其中一个时，用 union 把它们挤进同一块内存。
- 类型双关（type punning）：安全地按不同类型解读同一段比特位（比如拆解一个
float的符号/阶码/尾数），比reinterpret_cast更合规。 - C++17 后推荐用
std::variant替代手写 union，更安全。
C++ 中 using 和 typedef 的区别?
两者都是给类型起别名，但using更强大：
typedef：只能给已有类型起别名，语法是typedef 旧类型 新名字;using：语法是using 新名字 = 旧类型;，更直观，并且支持模板别名（typedef做不到）。
typedef unsigned int uint_t; // 旧写法 using uint_t = unsigned int; // 新写法，顺序更自然 // 模板别名 —— using 的杀手锏，typedef 写不出 template<typename T> using Vec = std::vector<T>; // 现在 Vec<int> == std::vector<int>一句话：能用 using 就用 using，只有"给模板起别名"这一条 typedef 就被秒杀了。
C++ 中 enum 和 enum class 的区别?
- enum（无作用域枚举 / 弱类型枚举）：
- 枚举值直接暴露在外层作用域，可以直接写
Red。 - 会隐式转换为整型，容易引发意外比较/赋值。
- 不同 enum 之间名字会冲突。
- 枚举值直接暴露在外层作用域，可以直接写
- enum class（强类型枚举，C++11 引入）：
- 枚举值必须带作用域：
Color::Red，不会污染外层。 - 不会隐式转 int，要转必须显式
static_cast<int>(Color::Red)，更安全。 - 可以指定底层类型：
enum class Color : uint8_t { ... };
- 枚举值必须带作用域：
enum Color { Red, Green }; // Red 直接可见，能隐式转 int enum class Fruit { Apple, Banana }; // 必须写 Fruit::Apple，不能隐式转 int x = Red; // OK（弱枚举） int y = Fruit::Apple; // 编译报错（强枚举）一句话：enum 弱、会隐式转换、名字会冲突；enum class 强、要带作用域、显式转换更安全。
C++ 中 new 和 malloc 的区别？delete 和 free 的区别?
| 对比项 | new / delete | malloc / free |
|---|---|---|
| 本质 | 运算符（可重载） | 库函数 |
| 内存 + 构造 | 分配内存并调用构造函数 | 只分配内存，不构造 |
| 释放 + 析构 | 调用析构函数再释放内存 | 只释放内存，不析构 |
| 返回类型 | 返回对应类型指针，类型安全 | 返回void*，需要强转 |
| 失败行为 | 抛异常std::bad_alloc | 返回nullptr |
| 是否可重载 | 可以在类级别自定义 operator new | 不能重载 |
⚠️必须搭配使用：new 配 delete、malloc 配 free，混用是未定义行为（new 出来的对象用 free 会导致析构函数不执行）。
一句话：new/delete 会调构造/析构，malloc/free 只搬内存。
C++ 中类定义中 delete 关键字和 default 关键字的作用?
C++11 引入，用来显式控制编译器自动生成的特殊成员函数（构造/析构/拷贝/移动等）：
=default：显式告诉编译器"用默认实现生成这个函数"。常用于：- 你自定义了某个构造函数后，编译器就不再生成默认构造了，这时手写
A() = default;把它要回来。 - 让代码意图更清晰。
- 你自定义了某个构造函数后，编译器就不再生成默认构造了，这时手写
=delete：禁用某个函数，任何调用都会编译报错。常用于：- 禁止拷贝：
A(const A&) = delete; A& operator=(const A&) = delete;（单例、不可复制的资源类常用）。 - 禁止某些危险参数类型（比如禁止指针隐式转换）。
- 禁止拷贝：
class A { public: A() = default; // 用默认实现 A(const A&) = delete; // 禁拷贝构造 A& operator=(const A&) = delete; // 禁拷贝赋值 A(int) {} A(long) = delete; // 禁止 long 隐式转换构造 };一句话：=default 要默认实现，=delete 直接禁用。
C++ 中 this 指针的作用?
this是编译器偷偷给每个非静态成员函数加的一个隐藏形参，类型是ClassName* const，指向调用该函数的那个对象。
作用：
- 指代当前对象：函数体内访问成员时，本质是
this->成员。 - 区分同名形参和成员：
this->name = name; - 实现链式调用：成员函数返回
*this（返回引用），就能obj.f1().f2().f3();。 - 多态的基石：虚函数靠
this指向的对象的 vptr 完成动态绑定。
class Builder { int val_ = 0; public: Builder& add(int x) { val_ += x; return *this; } // 返回 *this 支持链式 }; Builder b; b.add(1).add(2).add(3); // 链式调用静态成员函数没有 this 指针，所以只能访问静态成员。
C++ 中可以使用 delete this 吗?
语法上可以，但强烈不建议。要安全使用必须同时满足：
- 对象是通过
new在堆上分配的（不能是栈对象、不能是数组的一部分）。 - 调用
delete this;之后，绝对不能再访问该对象的任何成员、虚函数、this（包括函数返回后继续用对象本身）。 - 不能在析构函数里调用
delete this（会无限递归）。 - 调用它的成员函数本身不能是
delete this之后还继续访问成员的。
class Ref { public: void release() { delete this; // 自杀 // 这里之后绝不能再碰任何成员 } };实际工程里几乎都用智能指针（
shared_ptr/ 自定义 deleter）替代delete this。
C++ 中 vector 的原理？resize 和 reserve 的区别？size 和 capacity 的区别?
vector 原理：本质是三根指针管理一块连续的动态数组——start（头）、finish（已用尾）、end_of_storage（容量尾）。
- 当
finish == end_of_storage还要 push_back 时触发扩容：申请一块更大的新内存（通常是1.5 倍或 2 倍）→ 把旧元素**搬过去（能 move 就 move）**→ 释放旧内存 → 更新三根指针。
resize vs reserve：
resize(n) | reserve(n) | |
|---|---|---|
| 改变 size | ✅是 | ❌否 |
| 改变 capacity | 可能 | ✅是 |
| 初始化/构造元素 | ✅会（默认值或指定值） | ❌不会 |
| 缩小 | 会删掉多余的元素 | 无效（capacity 不会缩小） |
size vs capacity：
size()：当前实际存了多少个元素（finish - start）。capacity()：当前已分配的容量，即最多能存多少个元素（end_of_storage - start）。当size > capacity时触发扩容。
std::vector<int> v; v.reserve(100); // capacity=100, size=0，不构造任何元素 v.resize(10); // size=10，多出来的 10 个被初始化为 0 v.resize(5); // size=5，后面的元素被销毁，capacity 不变一句话：resize 动"有效元素数"，reserve 只动"容量上限"。
C++ 中 deque 的原理？它内部是如何实现的?
deque（双端队列）：支持头插/头删、尾插/尾删都是 O(1)，并且支持[]随机访问。
内部实现（关键考点）：
- 不是一整块连续内存，而是分段连续：底层是一组固定大小的小块连续内存（chunk / buffer），每个 chunk 都能存若干元素。
- 中间用一个**“中控 map”——本质是一个指针数组**（
T**），每个元素指向一个 chunk。这个 map 本身也是一段连续空间，两边不够时也会扩容。 - 头部 push：往前一个 chunk 的末尾塞；尾部 push：往后一个 chunk 的头部塞——所以两端都是 O(1)。
- 随机访问：通过
map[i / chunk_size]定位到第几个 chunk，再[i % chunk_size]取元素，所以是 O(1)（比 vector 稍慢，多了一次解引用）。
map: [chunk0*][chunk1*][chunk2*]... ↓ ↓ ↓ [....] [....] [....] ← 每个是一段连续内存一句话：deque = 分段连续数组 + 一个指针数组（map）当索引；两端 O(1)，随机访问也 O(1)。