智能指针与RAII
需要预先了解：
1. 原始指针的缺点
原始指针/裸指针：如int* p，需要手动管理内存，容易造成以下问题：
1. 忘记delete/free会导致内存泄露:
// 局部变量 ptr 指向的堆内存未释放，造成内存泄露
void func
{
Type* ptr = new Type();
ptr->do_something();
}2.使用释放后的悬挂指针，导致未定义行为：
Type* ptr = new Type();
delete ptr;
ptr->do_something();3. 重复释放同一块内存，导致未定义行为或程序崩溃
Type* ptr = new Type();
delete ptr;
delete ptr; // 重复释放同一块内存2. RAII（Resource Acquisition Is Initialization）
RAII（直译为“资源获取即初始化”）：在 对象构造阶段获取资源，在 对象析构阶段释放资源；依靠 C++ 对象自动生命周期管理（离开作用域自动调用析构），保证资源一定会被释放。
一个实现RAII管理资源的简单设计：
// Array.h
class Array
{
private:
int* data;
size_t size;
public:
Array(size_t size);
~Array();
// 不允许浅拷贝，可以看需求决定是否允许深拷贝
Array(const Array& other) = delete;
Array& operator=(const Array& other) = delete;
// 视情况决定是否允许移动
Array(Array&& other);
Array& operator=(Array&& other);
}这里给出函数的具体实现供参考：
// Array.cpp
Array::Array(size_t size)
{
data = new int[size]();
}
Array::~Array()
{
std::cout << "析构函数被调用，在这里释放内存" << std::endl;
delete[] data;
}
Array::Array(Array&& other)
{
data = other.data;
other.data = nullptr;
}
Array& Array::operator=(Array&& other)
{
if(this != &other)
{
data = other.data;
other.data = nullptr;
}
return *this;
}3. 智能指针
智能指针是原始指针的封装，会通过RAII的模式自动管理内存，确保资源在不再使用时被正确释放，避免内存泄漏和指针悬空等问题。智能指针定义在头文件<memory>，常见的智能指针有：
std::unique_ptrstd::shared_ptrstd::weak_ptr
3.1 std::unique_ptr：独占指针
独占语义：同一时刻，只能有一个 unique_ptr 拥有这块内存
- 禁止拷贝（拷贝构造与拷贝赋值）
- 允许移动进行所有权的转移
- 当
std::shared_ptr被销毁时，资源会被自动释放
1. std::shared_ptr的创建：语法为std::shared_ptr<变量类型>
#include <memory>
// 通过 原始指针 或 new 进行创建
int* raw_ptr = new int(10);
std::unique_ptr<int> uptr1(raw_ptr);
std::unique_ptr<int> uptr2(new int(20));
raw_ptr = nullptr; // 注意把 raw_ptr 置空，确保资源被 uptr1 独占
// 通过 make_unique 进行创建，最推荐最安全的方式
auto uptr3 = std::make_unique<int>(30);2. 和裸指针一样，通过 -> 和 * 操作符访问资源：
std::unique_ptr<MyClass> uptr1 = std::make_unique<MyClass>();
uptr1->member_function();
auto uptr2 = std::make_unique<int>();
std::cout << *uptr2 << std::endl;3. 可以通过 get() 方法获取地址/访问原始指针：
int *rawPtr = uniquePtr.get();4. 允许移动：
std::unique_ptr<int> uniquePtr1 = std::make_unique<int>(10);
std::unique_ptr<int> uniquePtr2 = std::move(uniquePtr1); // 转移所有权
if(!uniquePtr1) {
std::cout << "uniquePtr1 is empty" << std::endl; // uniquePtr1 现在为空
}5. 禁止拷贝：
std::unique_ptr<Data> a = std::make_unique<Data>();
std::unique_ptr<Data> b = a; // 编译报错！禁止拷贝3.2 std::shared_ptr共享指针 与 std::weak_ptr弱指针
std::shared_ptr
- 共享所有权：多个
std::shared_ptr可以指向同一个对象 - 控制块：在堆上分配，独立于管理对象；其中保存着强引用计数、弱引用计数与删除器
- 规则：
- 拷贝
shared_ptr，则强引用计数+1 shared_ptr析构/被赋值覆盖，则强引用计数-1- 当强引用计数为0时，销毁托管对象
- 当
weak_ptr全部销毁后释放控制块
- 拷贝
1. 创建std::shared_ptr：语法为std::shared_ptr<变量类型>
#include <memory>
// 通过原始指针创建
int *raw_ptr = new int(10);
std::shared_ptr<int> sptr1(raw_ptr);
raw_ptr = nullptr;
// 通过 new 创建
std::shared_ptr<int> sptr2(new int(20));
// 通过 make_shared 创建，最推荐的方式
std::shared_ptr<int> sptr3 = std::make_shared<int>(30);2. 获取引用计数：通过use_count()方法获取持有当前资源的shared_ptr的数目。
3. 释放所有权：通过reset()方法释放shared_ptr
std::shared_ptr<int> sptr1 = std::make_shared<int>(10);
std::shared_ptr<int> sptr2 = sptr1; // 共享资源，引用计数增加
std::cout << "引用计数: " << sptr1.use_count() << std::endl; // 输出 2
sptr2.reset(); // 释放 sptr2 的资源，引用计数减少
std::cout << "引用计数: " << sptr1.use_count() << std::endl; // 输出 1
sptr1.reset(); // 释放 sptr1 的资源，引用计数减少到 0，资源被释放4. 获取裸指针：通过get()方法
auto sptr = std::make_shared<int>(10);
int* raw_ptr = sptr.get();std::weak_ptr：
- 不拥有所有权，不影响强引用计数
- 不能直接访问对象，需要调用
lock()方法提升为shared_ptr- 如果资源已经被释放，则返回一个空的
shared_ptr - 如果资源未被释放，则返回一个指向资源的
shared_ptr
- 如果资源已经被释放，则返回一个空的
- 不能由裸指针构造，只能由
shared_ptr/weak_ptr赋值得到
auto sptr = std::make_shared<Node>();
std::weak_ptr<Node> wptr = sptr;
if(auto temp_ptr = wptr.lock())
{
temp_ptr->do_something();
}循环引用问题
两个对象互相持有对方的shared_ptr，导致引用计数永远无法归零，进而使得内存泄漏。
下面是一个循环引用的示例：
struct Node
{
int val;
std::shared_ptr<Node> partner;
Node(int v) : val(v) {}
};
void func()
{
auto a = std::make_shared<Node>(1);
auto b = std::make_shared<Node>(2);
a->partner = b, b->partner = a; // a,b互相持有对方
}在函数func()调用时，堆上的两个Node对象的的shared_ptr的引用计数都是2，但是当func()结束后，a、b被销毁，引用计数从2变成了1，对象不会被析构，造成了内存泄漏。
解决方案：把其中一个shared_ptr换为weak_ptr：
struct Node
{
int val;
std::weak_ptr<Node> next; // 改成 weak_ptr
Node(int v) : val(v) {}
};相关推荐
2026-10-23
静态库与动态库的基础知识
需要预先学习： 内存基础 虚拟地址 extern、static 与 inline 关键字总结 extern “C” 库 假设有一些许多项目都要用到的函数，比如在某一个项目里面写了个 calculate.cpp。此时如果另一个项目也想用这几个函数，最直接的做法是把源码复制过去。但是这种做法会导致以下几个问题： 如果有很多项目都想用到这份代码，需要多次重复复制一样的源码 如果发现其中有一个 bug，进行修复时需要在每个项目里都改一遍 每个项目都要单独编译这份代码，会造成编译时间延长，也会导致生成的二进制文件体积膨胀 有可能会出现不同项目中的 ``calculate.cpp` 版本不一致，导致行为不一致 库（library）就是为解决这类问题出现的。它是一批已经编译好的目标代码，连同符号表、重定位信息、初始化信息等元数据打包在一起。库可以被链接器合并进可执行文件，也可以在程序运行时被加载器映射进进程的地址空间。 从使用者的角度看，库提供了两样东西： 一组可以调用的符号（函数名、变量名），以及它们对应的机器码和数据 一份 ABI（Applica...
2026-08-31
类的内存占用
需要预先了解： 类与对象 内存基础 多态 类的实例的内存占用 类的实例（对象）的内存占用，指的是 sizeof(类名) 的结果——它只统计数据成员和编译器为支持语言特性而插入的隐藏成员（如虚表指针），不包含静态成员变量和成员函数。先看一组真实测量（64 位平台）： #include <cstdio> class Empty {}; // 空类 class WithInt { public: int x; }; class WithVirt { public: virtual void f() {} int x; }; class WithStatic { public: static int s; // 静态成员变量 int x; }; int WithStatic::s = 0; int main() { prin...
2026-09-03
多线程编程基础
基础概念 多线程编程之前，先搞清楚几个基本概念：并发、并行、进程、线程、协程。它们经常被混用，但含义差别很大，而且这些差异最终都落在硬件层面。 并发与并行 并发（concurrency）指多个任务在同一时间段内交替推进——宏观上看它们"同时"在进行，微观上可能只有一个执行单元在轮流处理。并行（parallelism）指多个任务在同一时刻真正同时执行，这要求有多个执行单元（多个 CPU 核心）。 两者的关系可以用一个经典表述概括：并发是程序结构层面的性质，并行是执行层面的性质。一个程序可以设计成并发的（多个任务交替推进），但只有在多核机器上运行时才可能并行。 单核并发（时间片轮流）： CPU 核心: [任务A][任务B][任务A][任务B][任务A][任务B] ... └── 每个时刻只有 1 个任务在跑 ──┘ 双核并行： 核心 1: [任务A][任务A][任务A][任务A] ... 核心 2: [任务B][任务B][任务B][任务B] ... └── 同一时刻有 2 个任务在跑 ──┘ 注意：并发程序...
2026-07-22
函数指针与std::function
需要预先了解： 函数 指针 函数指针 函数的地址 函数的机器指令存储在内存的.text段里，每个函数对应.text段中的一段连续的机器指令序列，其起始地址（即函数第一条指令所在的内存地址）就是这个函数的地址。 函数指针 函数指针是指向函数的指针类型，它存储函数的入口地址，通过这个地址可以间接调用对应的函数。 其声明语法为返回值类型 (*函数指针名)(参数列表)： int add(int a, int b); int (*p)(int, int); // p 是类型为 int (*)(int, int)的函数的指针 函数名也可以隐式转换为函数的入口地址 因此有以下两种等价的写法： int (*p)(int, int) = add; int (*p)(int, int) = &add; 调用函数指针也有等价的两种写法： std::cout << p(1, 2) << std::endl; std::cout << (*p)(1, 2) << std::endl; std::function std:...
2026-07-24
联合与std::variant
需要预先了解： 内存基础 变量与常量 联合（Union） 联合（union） 是一种特殊的数据类型，它允许在同一块内存空间中存储不同类型的数据，但同一时刻只能有一个成员是有效的。定义语法与 struct 类似，只是把关键字换为 union： union Data { int i; double d; char c; }; 使用时像结构体一样访问成员，但所有成员共享同一块内存： #include <iostream> int main() { Data u; u.i = 42; // 写入 int std::cout << u.i << std::endl; // 输出: 42 u.d = 3.14; // 写入 double——覆盖了原来的 int std::cout << u.d << std::endl; /...
2026-09-05
CRTP（奇异递归模板模式）
需要预先学习： 模版基础 继承 多态 CRTP（奇异递归模板模式） CRTP（Curiously Recurring Template Pattern，奇异递归模板模式）是一种继承写法：派生类把自己作为模版参数传给基类。 template <typename Derived> class Base { // 基类通过模版参数 Derived "知道"派生类是谁 }; class Widget : public Base<Widget> // Widget 把自己传给 Base { }; 这样基类在编译期就知道"谁继承了我"，可以直接使用派生类的类型——由此得到一类不依赖 virtual 的多态能力，称为静态多态（static polymorphism，编译期多态）。 最小示例 #include <iostream> template <typename Derived> class Base { public: void inter...
