1.8 C/C++ 虚函数 && 并行

一、纯虚函数是什么

形式：virtual 返回类型 虚函数名（形参表）= 0；

含有虚函数的类会变成抽象类，该类只能被继承而不能被实例化对象。纯虚函数永远不会被调用，主要是用来统一管理子对象。

二、什么函数不能被声明为虚函数

• 普通函数；
• 静态成员函数；
• 内联成员函数（内联函数是为了减少调用代价，而虚函数是为了多态，这两者之间矛盾，并且内联函数在编译的时候就已经展开）；
• 构造函数；
• 友元函数

三、C++中如何阻止一个类被实例化？

将类的成员函数写成纯虚函数，变成抽象类。

四、std::thread

（1）基本用法

1）创建线程：通过函数、Lambda 或成员函数创建线程：

关键点：

线程在构造时立即开始执行（无需手动启动）。

必须调用 join()或 detach()，否则程序终止时可能崩溃（std::terminate）。

#include <iostream>
#include <thread>

// 普通函数
void hello() {
    std::cout << "Hello from thread!\n";
}

// 带参数的函数
void print_num(int num) {
    std::cout << "Number: " << num << "\n";
}

int main() {
    // 方式1：绑定普通函数
    std::thread t1(hello);

    // 方式2：绑定带参数的函数
    std::thread t2(print_num, 42);

    // 方式3：Lambda 表达式
    std::thread t3([]() {
        std::cout << "Lambda thread!\n";
    });

    // 等待线程结束
    t1.join();
    t2.join();
    t3.join();

    return 0;
}

2）线程的 join()和 detach()

（2）线程传参

1）值传递 vs. 引用传递

值传递：参数被拷贝到线程的栈中（默认行为）。

引用传递：需显式使用 std::ref或 std::cref。

void modify(int& x) {
    x = 100;
}

int main() {
    int a = 0;

    // 错误：默认按值传递，无法修改外部变量
    // std::thread t1(modify, a);

    // 正确：使用 std::ref 传递引用
    std::thread t2(modify, std::ref(a));
    t2.join();

    std::cout << "a = " << a << "\n";  // 输出: a = 100
    return 0;
}

2） 传递类成员函数

需绑定对象实例：

class Worker {
public:
    void run() {
        std::cout << "Worker thread!\n";
    }
};

int main() {
    Worker worker;
    std::thread t(&Worker::run, &worker);  // 传递成员函数和对象指针
    t.join();
    return 0;
}

五、std::mutex

#include <mutex>

std::mutex mtx;
int counter = 0;

void increment() {
    mtx.lock();
    counter++;
    mtx.unlock();
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << "\n";  // 输出: Counter: 2
    return 0;
}

void increment() {
    std::lock_guard<std::mutex> lock(mtx);  // 超出作用域后会自动释放锁
    counter++;
}

六、std::condition_variable

#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });  // 等待条件满足
    std::cout << "Worker woke up!\n";
}

int main() {
    std::thread t(worker);
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();  // 通知等待的线程

    t.join();
    return 0;
}