C++ 核心学习笔记：指针、内存与零拷贝实战

3 noexcept

简单来说：移动构造 / 赋值加 noexcept，是让 MyString 既能享受'移动语义'的高性能，又能保证异常安全，同时兼容 STL 容器的设计逻辑——这也是 C++ 实现'零开销抽象'的关键细节。

例子：重写 MyString

#include <iostream>
#include <cstring>
#include <utility>

using namespace std;

class MyString {
private:
    char* _data;
    size_t _size;
    size_t _capacity;

    void allocateAndCopy(const char* str, size_t len) {
        _size = len;
        _capacity = len + 1;
        _data = new char[_capacity];
        strcpy_s(_data, _capacity, str);
    }
public:
    // 默认构造函数
    MyString(const char* str = "") {
        size_t len = strlen(str);
        allocateAndCopy(str, len);
        cout << "默认构造函数:" << _data << endl;
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        allocateAndCopy(other._data, other._size);
        cout << "拷贝构造函数:" << _data << endl;
    }

    // 拷贝赋值函数
    MyString& operator=(const MyString& other) {
        allocateAndCopy(other._data, other._size);
        cout << "拷贝赋值函数:" << _data << endl;
        return *this;
    }

    // 移动构造函数（浅拷贝资源 + 置空原对象，右值引用参数）
    MyString(MyString&& other) noexcept {
        _data = other._data;
        _size = other._size;
        _capacity = other._capacity;
        other._data = nullptr;
        other._size = 0;
        other._capacity = 0;
        cout << "移动构造函数:" << _data << endl;
    }

    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] _data;
            _data = other._data;
            _size = other._size;
            _capacity = other._capacity;
            other._data = nullptr;
            other._size = 0;
            other._capacity = 0;
        }
        cout << "移动赋值运算符:" << _data << endl;
        return *this;
    }

    ~MyString() {
        cout << "析构:" << (_data ? _data : "nullptr") << endl;
        delete[] _data;
    }

    const char* c_str() const { return _data; }
    size_t size() const { return _size; }
};

4 常见头文件

① C++ 标准库头文件

② Linux 系统错误处理头文件

③ Socket 网络编程核心头文件

④ 文件操作 / 零拷贝相关头文件

5 用户态和内核态

操作系统为了安全和权限管控，把 CPU 的执行权限分成了两个等级——普通程序只能在「用户态」运行（低权限），只有操作系统内核能在「内核态」运行（高权限）。

① 为什么要分用户态 / 内核态？

计算机的核心资源（CPU、内存、磁盘、网卡、显卡等）必须由操作系统统一管理，不能让普通程序直接操作——否则会出大问题：

• 比如一个普通程序直接写磁盘，可能覆盖系统文件；
• 一个程序直接操作网卡，可能窃取其他程序的网络数据；
• 多个程序同时申请内存，可能导致内存混乱。

因此操作系统做了「权限隔离」：

普通程序（比如 C++ 代码）默认跑在用户态，想要操作硬件 / 核心资源，必须「请求内核帮忙」——这个请求过程就是「系统调用（syscall）」，比如 open()/socket()/sendfile() 都是系统调用。

② 一个极简例子：直观理解态切换

比如代码 open() 函数（打开文件），看似简单，实际执行流程是：

// 你的代码（用户态）
int fileFd = open("/tmp/test.txt", O_RDONLY);

背后的真实流程：

1. 你的程序在用户态执行 open()，发现这是系统调用，触发 CPU 权限切换；
2. CPU 从用户态切到内核态，执行内核的 open() 逻辑（检查文件权限、分配文件描述符、读取磁盘目录）；
3. 内核完成操作后，CPU 从内核态切回用户态，把 fileFd 返回给你的程序。

这个'切来切去'的过程有开销，而零拷贝不仅减少了拷贝，还减少了态切换次数（传统方式 2 次切换，零拷贝 1 次），因此性能更高。

③ 关键知识点

1. 核心目的：用户态 / 内核态分离是为了「权限隔离 + 系统安全」，防止普通程序乱操作核心资源；
2. 系统调用：普通程序访问核心资源的唯一合法方式，会触发「用户态↔内核态」切换；
3. 跨态拷贝：数据在用户态和内核态之间的拷贝需要 CPU 参与，是性能瓶颈；
4. 零拷贝的本质：让数据全程在内核态流转，跳过用户态，避免跨态拷贝和多余的态切换。

6 零拷贝

零拷贝是操作系统 / 编程层面的优化技术，核心目标是：减少数据在「用户态内存」和「内核态内存」之间的拷贝次数，甚至完全避免不必要的拷贝，从而提升文件 / 网络传输的性能（降低 CPU 开销、减少内存占用、提高吞吐量）。

先理解：传统数据传输的'拷贝痛点'

以「Linux 下从文件读取数据并通过 Socket 发送」为例，传统方式（read + write）的流程是：

磁盘 → 内核态缓冲区（kernel buffer）→ 用户态缓冲区（user buffer）→ 内核态 Socket 缓冲区 → 网卡 

这个过程包含 4 次数据拷贝 + 2 次用户态 / 内核态切换：

1. read()：磁盘 → 内核缓冲区（DMA 拷贝，无 CPU 参与）；
2. read()：内核缓冲区 → 用户缓冲区（CPU 拷贝）；
3. write()：用户缓冲区 → Socket 内核缓冲区（CPU 拷贝）；
4. write()：Socket 内核缓冲区 → 网卡（DMA 拷贝，无 CPU 参与）。

其中，第 2、3 步的 CPU 拷贝是完全冗余的——数据只是'路过'用户态，没有任何修改，却消耗了 CPU 和内存带宽。

① 零拷贝的核心优化：跳过用户态拷贝

零拷贝的核心思路是：让数据直接在内核态流转，不进入用户态，常见实现方式有 2 种（Linux 下）：

a. sendfile() 系统调用（最常用）

代码中 <sys/sendfile.h> 就是为这个函数服务的，它的流程：

磁盘 → 内核态缓冲区 → 内核态 Socket 缓冲区 → 网卡 

• 拷贝次数：3 次（2 DMA 拷贝，1 CPU）；
• 切换次数：2 次（用户态→内核态→用户态）；
• 核心逻辑：sendfile() 直接在内核中完成'内核缓冲区 → Socket 缓冲区'的转发，数据全程不进入用户态。

b. splice()/tee() 系统调用（更极致）

进一步优化：连'内核缓冲区 → Socket 缓冲区'的拷贝都跳过，通过内存地址映射让两个内核缓冲区共享数据，流程：

磁盘 → 内核态缓冲区（映射到 Socket 缓冲区）→ 网卡 

• 拷贝次数：1 次（磁盘→内核缓冲区，DMA 拷贝）；
• 核心逻辑：数据始终只存在于内核缓冲区，Socket 直接'引用'该缓冲区，无任何实际拷贝。

② 极简示例（对比传统方式 vs 零拷贝）

a. 传统方式（read + write，冗余拷贝）

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <iostream>

void sendFile_traditional(int clientFd, const char* filePath) {
    int fileFd = open(filePath, O_RDONLY);
    if (fileFd < 0) {
        std::cerr << "open failed: " << strerror(errno) << std::endl;
        return;
    }
    char buf[4096]; // 用户态缓冲区
    ssize_t n;
    // 循环：读（内核→用户）→ 写（用户→内核）
    while ((n = read(fileFd, buf, sizeof(buf))) > 0) {
        write(clientFd, buf, n); // 每次都要 CPU 拷贝
    }
    close(fileFd);
}

b. 零拷贝方式（sendfile()，无用户态拷贝）

#include <sys/sendfile.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <iostream>

void sendFile_zerocopy(int clientFd, const char* filePath) {
    int fileFd = open(filePath, O_RDONLY);
    if (fileFd < 0) {
        std::cerr << "open failed: " << strerror(errno) << std::endl;
        return;
    }
    off_t offset = 0; // 直接在内核态转发数据，无用户态拷贝
    ssize_t sent = sendfile(clientFd, fileFd, &offset, 1024 * 1024);
    if (sent < 0) {
        std::cerr << "sendfile failed: " << strerror(errno) << std::endl;
    } else {
        std::cout << "发送 " << sent << " 字节（零拷贝）" << std::endl;
    }
    close(fileFd);
}

③ 零拷贝的核心价值（为什么要用）

④ 关键知识点

a '零拷贝'不是真的零拷贝

• 是'零 CPU 拷贝'，DMA 拷贝（硬件直接操作内存）仍存在，只是 DMA 不消耗 CPU；
• 核心是跳过'用户态缓冲区'这个中间环节。

b 适用场景

• 大文件传输（如视频、日志、静态资源）；
• 高性能网络服务（如 Web 服务器、文件服务器）；
• 数据无需修改的场景（若要修改数据，必须进入用户态，零拷贝不适用）。

c 核心 API

• Linux：sendfile()、splice()、tee()；
• Java：FileChannel.transferTo()（底层封装 sendfile）；
• Windows：TransmitFile()。

7 单例模式

① 单例模式定义

单例模式是**设计模式中'创建型模式'**的一种，核心目标是：保证一个类在程序运行期间，全局只创建一个实例对象，且提供一个全局唯一的访问入口。

② 单例模式的核心要求

要实现单例，必须满足 3 个条件：

1. 私有构造函数：禁止外部直接 new 该类对象（否则能创建多个实例）；
2. 私有拷贝构造 / 赋值运算符：禁止通过拷贝 / 赋值创建新实例；
3. 静态公有接口：提供全局唯一的访问入口（如 instance()），负责创建 / 返回唯一实例。

③ C++ 单例模式的常见实现

a. 饿汉式单例（最简单，推荐小型程序）

核心逻辑：程序启动时（静态变量初始化阶段）就创建实例，线程安全（C++11 后静态变量初始化是线程安全的）

#include <iostream>

using namespace std;

class Logger : noncopyable {
private:
    // 1. 私有构造函数：外部不能 new
    Logger() { cout << "Logger 构造（饿汉式）" << endl; }

    // 2. 静态私有实例：程序启动时就初始化（全局唯一）
    static Logger instance_;

public:
    // 3. 静态公有接口：返回唯一实例
    static Logger& instance() {
        return instance_; // 直接返回已创建的实例
    }

    // 日志方法（示例）
    void log(const string& msg) { cout << "日志：" << msg << endl; }

    // 禁用拷贝
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
};

// 静态实例初始化（必须在类外定义）
Logger Logger::instance_;

// 测试调用
int main() {
    // 多次调用 instance()，拿到的是同一个对象
    Logger& logger1 = Logger::instance();
    logger1.log("第一次调用");
    Logger& logger2 = Logger::instance();
    logger2.log("第二次调用");
    cout << "logger1 地址：" << &logger1 << endl;
    cout << "logger2 地址：" << &logger2 << endl; // 和 logger1 地址相同
    return 0;
}

特点：

• 优点：实现简单、线程安全（无需加锁）、无内存泄漏风险；
• 缺点：实例在程序启动时就创建，即使没用到也会占用内存（比如日志类如果全程没调用，也会初始化）。

b. 懒汉式单例（懒加载，推荐大型程序）

核心逻辑：第一次调用 instance() 时才创建实例（懒加载），节省内存；C++11 后用'局部静态变量'实现，天然线程安全。

class Logger {
private:
    // 私有构造函数
    Logger() { cout << "Logger 构造（懒汉式）" << endl; }

public:
    // 静态公有接口：第一次调用时创建实例
    static Logger& instance() {
        static Logger instance_; // 局部静态变量：仅第一次调用时初始化
        return instance_;
    }

    void log(const string& msg) { cout << "日志：" << msg << endl; }

    // 禁用拷贝
    Logger(const Logger&) = delete;
    Logger& operator=(const Logger&) = delete;
};

// 测试调用
int main() {
    cout << "程序启动，还没创建 Logger 实例" << endl;
    // 第一次调用：创建实例
    Logger& logger1 = Logger::instance();
    logger1.log("第一次调用");
    // 第二次调用：返回已创建的实例
    Logger& logger2 = Logger::instance();
    logger2.log("第二次调用");
    return 0;
}

特点：

• 优点：懒加载（不用不创建）、线程安全（C++11 局部静态变量初始化是原子操作）、实现简洁；
• 缺点：C++11 前需手动加锁（如 std::mutex），否则多线程调用会创建多个实例。

多线程下单例的核心问题：懒汉式初始化时，多个线程同时创建实例，破坏唯一性；

C++11 及以上优先用'局部静态变量懒汉式'（更简洁），兼容旧版本用 call_once + once_flag。

8 private protect public

三者的访问权限可总结为：

继承方式对权限的影响

子类继承父类时（public/protected/private 继承），会改变父类成员在子类中的访问权限，核心规则：

9 C++ 变量作用域

• 局部作用域：在函数内部声明的变量具有局部作用域，它们只能在函数内部访问。局部变量在函数每次被调用时被创建，在函数执行完后被销毁。
• 全局作用域：在所有函数和代码块之外声明的变量具有全局作用域，它们可以被程序中的任何函数访问。全局变量在程序开始时被创建，在程序结束时被销毁。
• 块作用域：在代码块内部声明的变量具有块作用域，它们只能在代码块内部访问。块作用域变量在代码块每次被执行时被创建，在代码块执行完后被销毁。
• 类作用域：在类内部声明的变量具有类作用域，它们可以被类的所有成员函数访问。类作用域变量的生命周期与类的生命周期相同。

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。

当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：

10 栈 vs 堆

① 概念对比

② C++ 不同数据的存储位置汇总表

③ 补充说明：

1. 全局 / 静态区：独立于栈和堆，存储全局变量、static 变量，程序启动时分配，结束时释放；
2. 常量区：存储字符串常量、const 全局常量，只读属性，不可修改；
3. 代码区：存储函数的二进制执行代码，只读，与数据区分离；
4. 堆内存的坑：
   • 忘记 delete 会导致内存泄漏（程序运行中占用内存不释放）；
   • 重复 delete 或 delete 后使用指针会导致野指针（未定义行为）；
   • C++11 后推荐用智能指针（unique_ptr/shared_ptr）管理堆内存，避免手动释放。
5. 栈地址通常是'高地址'且连续；堆地址是'低地址'且分散；全局 / 静态区地址介于栈和堆之间；常量区地址与全局区接近但只读。

11 static VS const

12 c++ 存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

• auto：这是默认的存储类说明符，通常可以省略不写。auto 指定的变量具有自动存储期，即它们的生命周期仅限于定义它们的块（block）。auto 变量通常在栈上分配。
• register：用于建议编译器将变量存储在 CPU 寄存器中以提高访问速度。在 C++11 及以后的版本中，register 已经是一个废弃的特性，不再具有实际作用。
• static：用于定义具有静态存储期的变量或函数，它们的生命周期贯穿整个程序的运行期。在函数内部，static 变量的值在函数调用之间保持不变。在文件内部或全局作用域，static 变量具有内部链接，只能在定义它们的文件中访问。
• extern：用于声明具有外部链接的变量或函数，它们可以在多个文件之间共享。默认情况下，全局变量和函数具有 extern 存储类。在一个文件中使用 extern 声明另一个文件中定义的全局变量或函数，可以实现跨文件共享。
• mutable (C++11)：用于修饰类中的成员变量，允许在 const 成员函数中修改这些变量的值。通常用于缓存或计数器等需要在 const 上下文中修改的数据。

#include <iostream>

class Example {
public:
    Example() : value(0), cachedValue(0) {}

    // 常量成员函数
    int getValue() const {
        return value; // 读取常量成员
    }

    // 修改 mutable 成员
    void increment() {
        ++value;
        cachedValue = value * 2; // 修改 mutable 成员
    }

    int getCachedValue() const {
        return cachedValue; // 读取 mutable 成员
    }

private:
    int value;             // 常规成员，不能在 const 函数中修改
    mutable int cachedValue; // 可修改成员，可以在 const 函数中修改
};

int main() {
    const Example ex; // ex.increment(); // 错误：无法在 const 对象上调用非 const 函数
                      // ex.value = 10; // 错误：无法修改 const 对象的成员
    std::cout << "Value: " << ex.getValue() << std::endl;
    std::cout << "Cached Value: " << ex.getCachedValue() << std::endl; // 输出为 0
    return 0;
}

• thread_local (C++11)：用于定义具有线程局部存储期的变量，每个线程都有自己的独立副本。线程局部变量的生命周期与线程的生命周期相同。在操作系统中，线程的执行由 CPU 调度器决定，而调度器采用'抢占式'策略：
  • 即使t1先被创建（std::thread t1(...)），也不代表t1会先获得 CPU 执行权——调度器可能先调度t2，导致t2先进入thread_func、先加锁、先输出。

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::mutex mtx;
thread_local int tl_id;

void thread_func(int id) {
    //mtx.lock();
    std::lock_guard<std::mutex> lock(mtx);
    tl_id = id + 3;
    std::cout << "thread:" << id << " tl_id = " << tl_id << std::endl;
    //mtx.unlock();
}

int main() {
    std::thread t1(thread_func, 1);
    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // 强制 t1 先加入调度区
    std::thread t2(thread_func, 2);
    t1.join();
    t2.join();
    return 0;
}

13 c++ 获取时间

ctime, localtime 是 C 标准库中不安全的函数（返回指向全局静态缓冲区的指针，线程不安全 + 缓冲区溢出风险），VS 编译器推荐改用微软扩展的安全版本 ctime_s, localtime_s。

#include <iostream>
#include <ctime>     // std::tm、std::localtime
#include <iomanip>   // std::put_time（核心！缺一不可）
#include <chrono>    // C++11 时间库
#include <cstring>

void getTime01() {
    time_t now = time(0);
    // char* dt = ctime(&now); 存在风险
    char dt[26];
    errno_t err = ctime_s(dt, sizeof(dt), &now);
    if (err == 0) {
        std::cout << "本地时间和日期：" << dt << std::endl;
    } else {
        std::cerr << "获取时间失败，错误码：" << err << std::endl;
    }
}

void getTime02() {
    time_t now = time(0);
    std::cout << "1900 年到现在进过秒数：" << now << std::endl;
    // tm* ltm = localtime(&now); 不安全
    tm ltm{};
    errno_t err = localtime_s(&ltm, &now);
    std::cout << "年：" << 1900 + ltm.tm_year << std::endl;
    std::cout << "月：" << 1 + ltm.tm_mon << std::endl;
    std::cout << "日：" << ltm.tm_mday << std::endl;
    std::cout << "星期：" << ltm.tm_wday << std::endl;
    std::cout << "小时：" << ltm.tm_hour << std::endl;
    std::cout << "分钟：" << ltm.tm_min << std::endl;
    std::cout << "秒：" << ltm.tm_sec << std::endl;
}

void getTime03() {
    auto now = std::chrono::system_clock::now();
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);
    std::cout << now_c << std::endl;
    std::tm ltm{};
#ifdef _MSC_VER // VS 编译器
    localtime_s(&ltm, &now_c);
#else // GCC/Clang
    localtime_r(&now_c, &ltm); // Linux/macOS 的安全版本
#endif
    // 4. 输出各个时间字段（修正了 tm_wday 的含义）
    std::cout << "1970 年到现在经过秒数：" << now_c << std::endl;
    std::cout << "年：" << 1900 + ltm.tm_year << std::endl; // 注意：tm_year 是从 1900 开始，不是 1970！
    std::cout << "月：" << 1 + ltm.tm_mon << std::endl;     // tm_mon=0(1 月)~11(12 月)
    std::cout << "日：" << ltm.tm_mday << std::endl;       // 日期（1~31）
    std::cout << "星期：" << ltm.tm_wday << std::endl;     // 0(周日)~6(周六)
    std::cout << "小时：" << ltm.tm_hour << std::endl;     // 0~23
    std::cout << "分钟：" << ltm.tm_min << std::endl;      // 0~59
    std::cout << "秒：" << ltm.tm_sec << std::endl;        // 0~60（闰秒）
    std::cout << "完整时间（put_time）" << std::put_time(&ltm, "%Y-%m-%d %H:%M:%S") << std::endl;
}

int main() {
    getTime01();
    getTime02();
    getTime03();
}

14 c++ 文件和流

可以把以上两种或两种以上的模式结合使用。例如，如果想要以写入模式打开文件，并希望截断文件，以防文件已存在，那么可以使用下面的语法：

ofstream outfile;
outfile.open("file.dat", ios::out | ios::trunc);

类似地，如果想要打开一个文件用于读写，可以使用下面的语法：

ifstream afile;
afile.open("file.dat", ios::out | ios::in);

例子：

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::ofstream ofs;
    ofs.open("text.txt", std::ios::out);
    // char data[100];
    std::string data;
    std::cout << "请输入名字";
    // std::cin.getline(data, 100); 不可以读空格
    std::getline(std::cin, data);
    ofs << data << std::endl;
    std::cout << "输入年龄：";
    std::cin >> data;
    ofs << data << std::endl;
    ofs.close();

    std::ifstream ifs;
    ifs.open("text.txt", std::ios::in);
    std::cout << "Reading from the file" << std::endl;
    while (std::getline(ifs, data)) // ifs>>data
    {
        std::cout << data << std::endl;
    }
    ifs.close();
    return 0;
}

15 c++ 信号

#include <iostream>
#include <csignal>
#include <Windows.h>

void signalHandler(int signum) {
    std::cout << "Interrupt siganl(" << signum << ") received" << std::endl;
    exit(signum);
}

int main() {
    int i = 0;
    signal(SIGINT, signalHandler);
    while (++i) {
        std::cout << "Going to sleep...." << std::endl;
        if (i == 4) {
            raise(SIGINT);
        }
        Sleep(2000);
    }
    return 0;
}

16 c++ 多线程

线程是程序中的轻量级执行单元，允许程序同时执行多个任务。

多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。

一般情况下，两种类型的多任务处理：基于进程和基于线程。

• 基于进程的多任务处理是程序的并发执行。
• 基于线程的多任务处理是同一程序的片段的并发执行。

C++ 多线程编程涉及在一个程序中创建和管理多个并发执行的线程。

① 概念

线程 (Thread)

• 线程是程序执行中的单一顺序控制流，多个线程可以在同一个进程中独立运行。
• 线程共享进程的地址空间、文件描述符、堆和全局变量等资源，但每个线程有自己的栈、寄存器和程序计数器。

并发 (Concurrency) 与并行 (Parallelism)

• 并发：多个任务在时间片段内交替执行，表现出同时进行的效果。
• 并行：多个任务在多个处理器或处理器核上同时执行。

C++11 及以后的标准提供了多线程支持，核心组件包括：

• std::thread：用于创建和管理线程。
• std::mutex：用于线程之间的互斥，防止多个线程同时访问共享资源。
• std::lock_guard 和 std::unique_lock：用于管理锁的获取和释放。
• std::condition_variable：用于线程间的条件变量，协调线程间的等待和通知。
• std::future 和 std::promise：用于实现线程间的值传递和任务同步。

② 三种创建线程的方式

a 函数指针

b 函数对象

c lambda 表达式

#include <iostream>
#include <thread>

void func01(int num) {
    for (int i = 0; i < num; i++) {
        std::cout << "create thread by ptr: thread(" << i << ")" << std::endl;
    }
}

class func02 {
public:
    void operator()(int num) const {
        for (int i = 0; i < num; i++) {
            std::cout << "create thread by object: thread(" << i << ")" << std::endl;
        }
    }
};

int main() {
    std::thread thread01(func01, 5);
    std::thread thread02(func02(), 5);
    std::thread thread03([](int num) {
        for (int i = 0; i < num; i++) {
            std::cout << "create thread by lambda: thread(" << i << ")" << std::endl;
        }
    }, 5);
    thread01.join();
    thread02.join();
    thread03.join();
    return 0;
}

③ 线程传参

值传递

参数可以通过值传递给线程：

std::thread t(func, arg1, arg2);

引用传递

如果需要传递引用参数，需要使用 std::ref：

#include <iostream>
#include <thread>

void increment(int& num) {
    num += 1;
}

int main() {
    int a = 6;
    std::thread thread01(increment, std::ref(a));
    thread01.join();
    std::cout << a << std::endl;
}

在 C++ 中，std::ref() 是定义在 <functional> 头文件中的工具函数，核心作用是将变量包装为'引用包装器（std::reference_wrapper）'，解决'值传递场景下无法传递真正引用'的问题（比如向线程、函数模板、绑定函数传参时）。

C++ 中很多场景（如 std::thread、std::bind、std::function、算法模板）的参数传递默认是值拷贝——即使你写了引用符号 &，也会被拷贝语义覆盖，无法真正传递引用。

场景强制拷贝'的核心含义是：某些 C++ 语法 / 库函数的设计规则，会强制把你传入的参数做一次'值拷贝'，哪怕你写了引用符号 &，也无法改变'传拷贝而非传引用'的结果。