C++11 核心特性：可变参数模板、Lambda 与线程库 | 极客日志

C++算法

C++11 核心特性：可变参数模板、Lambda 与线程库

涵盖 C++11 可变参数模板的展开方式（递归与逗号表达式）、Lambda 表达式的语法及捕获列表、Function 包装器与 Bind 适配器的使用，以及线程库的核心组件包括 Thread 类、Mutex 锁、Condition Variable 条件变量和 Atomic 原子操作，通过代码示例展示了多线程同步与并发编程的关键技术点。

嘘发布于 2026/3/15更新于 2026/4/170 浏览

九、可变参数模板

下面就是一个基本可变参数的函数模板：

// Args 是一个模板参数包，args 是一个函数形参参数包

{}

// 递归终止函数
template<class T>
void ShowList(const T& t) { cout << t << endl; }

// 展开函数
template<class T, class...Args>
void ShowList(T value, Args... args) {
    cout << value << " ";
    ShowList(args...);
}

int main() {
    ShowList("string");
    ShowList("string", "vector");
    ShowList("string", "vector", '6');
    return 0;
}

template<class T>
void PrintArg(T t) { cout << t << " "; }

// 展开函数
template<class...Args>
void ShowList(Args... args) {
    int arr[] = {(PrintArg(args), 0)...};
    cout << endl;
}

int main() {
    ShowList("string");
    ShowList("string", "vector");
    ShowList("string", "vector", '6');
    return 0;
}

template<class T>
int PrintArg(T&& t) { cout << t << " "; return 0; }

// 展开函数
template<class...Args>
void ShowList(Args&&... args) {
    // 要初始化 arr，强行让解析参数包，参数包有一个参数，PrintArg 就依次推演生成几个
    int arr[] = {PrintArg(args)...};
    cout << endl;
}

int main() {
    ShowList("string");
    ShowList("string", "vector");
    ShowList("string", "vector", '6');
    return 0;
}

template<class... Args>
void emplace_back(Args&&... args);

int main() {
    list<pair<string, string>> l;
    // emplace_back 支持可变参数，拿到构建 pair 对象的参数后自己去创建对象
    // 那么在这里我们可以看到除了用法上，和 push_back 没什么太大的区别
    l.emplace_back("love", "爱");
    l.emplace_back("want", "想要");
    l.emplace_back(make_pair("miss", "想念"));
    l.push_back(make_pair("I", "我"));
    l.push_back({"You", "你"});
    for(auto e : l) cout << e.first << ":" << e.second << endl;
    return 0;
}

int main() {
    // 下面我们试一下带有拷贝构造和移动构造的 aj::string，再试试呢
    // 我们会发现其实差别也不到，emplace_back 是直接构造了，
    // push_back 是先构造，再移动构造，其实也还好。
    list<pair<string, aj::string>> l;
    l.emplace_back("love", "爱");
    l.emplace_back(make_pair("miss", "想念"));
    cout << endl;
    l.push_back(make_pair("I", "我"));
    l.push_back({"You", "你"});
    cout << endl;
    return 0;
}

#include <algorithm>
#include <functional>

int main() {
    int array[] = {9, 2, 6, 4, 7, 1, 5, 3, 0};
    // 默认按照小于比较，排出来结果是升序
    sort(array, array + sizeof(array)/sizeof(array[0]));
    // 如果需要降序，需要改变元素的比较规则
    sort(array, array + sizeof(array)/sizeof(array[0]), greater<int>());
    return 0;
}

#include <algorithm>
#include <functional>

struct Goods {
    string _name; // 名字
    double _price; // 价格
    int _evaluate; // 评价
    Goods(const char* str, double price, int evaluate):_name(str),_price(price),_evaluate(evaluate){}
};

struct ComparePriceLess {
    bool operator()(const Goods& gl, const Goods& gr) {
        return gl._price < gr._price;
    }
};

struct ComparePriceGreater {
    bool operator()(const Goods& gl, const Goods& gr) {
        return gl._price > gr._price;
    }
};

int main() {
    vector<Goods> v = {{"苹果", 2.1, 5}, {"香蕉", 3, 4}, {"橙子", 2.2, 3}, {"菠萝", 1.5, 4}};
    sort(v.begin(), v.end(), ComparePriceLess());
    sort(v.begin(), v.end(), ComparePriceGreater());
    return 0;
}

#include <algorithm>
#include <functional>

struct Goods {
    string _name; // 名字
    double _price; // 价格
    int _evaluate; // 评价
    Goods(const char* str, double price, int evaluate):_name(str),_price(price),_evaluate(evaluate){}
};

int main() {
    vector<Goods> v = {{"苹果", 2.1, 5}, {"香蕉", 3, 4}, {"橙子", 2.2, 3}, {"菠萝", 1.5, 4}};
    sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr){
        return gl._price < gr._price;
    });
    sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr){
        return gl._price > gr._price;
    });
    return 0;
}

int main() {
    // 最简单的 lambda 表达式，没有任何意义
    []{};
    // 省略参数列表和返回值类型
    int x = 2, y = 5;
    [=]{ return x + 6; };
    // 省略返回值类型，并且这里没有返回值类型
    cout << "改变之前-->" << "x:" << x << " y:" << y << endl;
    auto func1 = [&](int z){ x = y + z; };
    func1(100);
    cout << "改变之后-->" << "x:" << x << " y:" << y << endl << endl;
    // 各部分都很完善的 lambda 函数
    cout << "改变之前-->" << "x:" << x << " y:" << y << endl;
    auto func2 = [=,&y](int z)->int{ return y += x + z; };
    func2(520);
    cout << "改变之后-->" << "x:" << x << " y:" << y << endl << endl;
    // 复制捕捉 x
    auto add_x = [x](int a) mutable{ x *= 2; return a + x; };
    cout << add_x(10) << endl;
    return 0;
}

int main() {
    auto func1 =[]{cout << "Chinese" << endl;};
    auto func2 =[]{cout << "Chinese" << endl;};
    cout << typeid(func1).name() << endl;
    cout << typeid(func2).name() << endl;
    return 0;
}

void(*PF)();
int main() {
    auto f1 =[]{cout << "Chinese" << endl;};
    auto f2 =[]{cout << "Chinese" << endl;};
    // f1 = f2; // 编译失败--->E0349 没有与这些操作数匹配的 "=" 运算符
    // 允许使用一个 lambda 表达式拷贝构造一个新的副本
    auto f3(f2);
    f3();
    cout << typeid(f2).name() << endl;
    cout << typeid(f3).name() << endl;
    // 可以将 lambda 表达式赋值给相同类型的函数指针
    PF = f2;
    PF();
    return 0;
}

struct TotalPrice {
    double operator()(int num, double unit_price) {
        return num * unit_price;
    }
};

int main() {
    auto TP = [](int num, double unit_price){ return num * unit_price; };
    TotalPrice()(50, 5.2);
    TP(50, 5.2);
    return 0;
}

template<class F, class T> T useF(F f, T x) {
    static int count = 0;
    cout << "count:" << ++count << endl;
    cout << "count:" << &count << endl;
    return f(x);
}

double f(double i) { return i / 2; }

struct Functor {
    double operator()(double d) { return d / 3; }
};

// ret = func(x);
// 上面 func 可能是什么呢？那么 func 可能是函数名？函数指针？函数对象 (仿函数对象)？
// 也有可能是 lambda 表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
int main() {
    // 函数名
    cout << useF(f, 11.11) << endl;
    // 函数对象
    cout << useF(Functor(), 11.11) << endl;
    // lambda 表达式
    cout << useF([](double d)->double{return d / 4;}, 11.11) << endl;
    return 0;
}

std::function 在头文件<functional>
// 类模板原型如下
template<class T> function; // undefined
template<class Ret, class... Args>
class function<Ret(Args...)>; // 模板参数说明：Ret:被调用函数的返回类型 Args…：被调用函数的形参

class ADD {
public:
    double addd(double x, double y) { return x + y; }
};

int main() {
    // 传类对象的指针
    function<double(ADD*, double, double)> func1 = &ADD::addd;
    ADD a;
    cout << "func1(&a, 5, 10)--><" << func1(&a, 5, 10) << endl;
    // 传对象
    function<double(ADD, double, double)> func2 = &ADD::addd;
    cout << "func2(ADD(), 5, 10)--><" << func2(ADD(), 5, 10) << endl;
    return 0;
}

#include <functional>
using namespace std;

int add(int x, int y) { return x + y; }

struct Add {
    int operator()(int x, int y) { return x + y; }
};

class ADD {
public:
    static int addi(int x, int y) { return x + y; }
    double addd(double x, double y) { return x + y; }
};

int main() {
    // 函数名 (函数指针)
    function<int(int, int)> func1 = add;
    cout << func1(5, 10) << endl;
    // 函数对象
    function<int(int, int)> func2 = Add();
    cout << func2(5, 10) << endl;
    // lambda 表达式
    function<int(int, int)> func3 = [](int x, int y)->int{return x + y;};
    cout << func3(5, 10) << endl;
    // 类的成员函数（静态函数）
    function<int(int, int)> func4 = &ADD::addi;
    cout << func4(5, 10) << endl;
    // 类的成员函数
    function<double(ADD, double, double)> func5 = &ADD::addd;
    cout << func5(ADD(), 5, 10) << endl;
    return 0;
}

#include <functional>
using namespace std;

template<class F, class T> T useF(F f, T x) {
    static int count = 0;
    cout << "count:" << ++count << endl;
    cout << "count:" << &count << endl;
    return f(x);
}

double f(double i) { return i / 2; }

struct Functor {
    double operator()(double d) { return d / 3; }
};

int main() {
    // 函数名
    function<double(double)> func1 = f;
    cout << useF(func1, 11.11) << endl;
    // 函数对象
    function<double(double)> func2 = Functor();
    cout << useF(func2, 11.11) << endl;
    // lambda 表达式
    function<double(double)> func3 = [](double d)->double{return d / 4;};
    cout << useF(func3, 11.11) << endl;
    return 0;
}

// 原型如下：
template<class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
// with return type (2)
template<class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

#include <functional>
using namespace std;

int add(int x, int y) { return x + y; }
int sub(int x, int y) { return x - y; }

struct Add {
    int operator()(int x, int y) { return x + y; }
};

class ADD {
public:
    static int addi(int x, int y) { return x + y; }
    double addd(double x, double y) { return x + y; }
};

int main() {
    // 表示绑定函数 add 参数分别由调用 func1 的第一，二个参数指定
    function<int(int, int)> func1 = bind(add, placeholders::_1, placeholders::_2);
    cout << func1(5, 10) << endl;
    // 参数调换顺序
    function<int(int, int)> func2 = bind(sub, placeholders::_1, placeholders::_2);
    cout << func2(5, 10) << endl;
    function<int(int, int)> func3 = bind(sub, placeholders::_2, placeholders::_1);
    cout << func3(5, 10) << endl;
    // 绑定类中静态函数
    function<int(int, int)> func4 = bind(ADD::addi, placeholders::_2, placeholders::_1);
    cout << func4(5, 10) << endl;
    // 绑定类的成员函数
    function<double(double, double)> func5 = bind(&ADD::addd, ADD(), placeholders::_2, placeholders::_1);
    cout << func5(5, 10) << endl;
    return 0;
}

thread() noexcept;

template<class Fn, class... Args>
explicit thread(Fn&& fn, Args&&... args);

thread(thread&& x) noexcept;

thread& operator=(thread&& rhs) noexcept;

id get_id() const noexcept;

bool joinable() const noexcept;

void join();

void detach();

void swap(thread& x) noexcept;

void lock();

bool try_lock();

void unlock();

void wait(unique_lock<mutex>& lck);

void notify_one() noexcept;

#include <iostream>
#include <vector>
#include <string>
#include <time.h>
using namespace std;
#include <thread>
#include <mutex>

int main() {
    mutex mtx;
    int x = 0;
    condition_variable cv;
    bool flag = false;
    thread th1([&](){
        for(int i = 0; i < 10; i++){
            unique_lock<mutex> lock(mtx);
            if(flag) cv.wait(lock);
            flag = true;
            cout << this_thread::get_id() << " : " << x++ << endl;
            cv.notify_one();
        }
    });
    thread th2([&](){
        for(int i = 0; i < 10; i++){
            unique_lock<mutex> lock(mtx);
            if(!flag) cv.wait(lock);
            flag = false;
            cout << this_thread::get_id() << " : " << x++ << endl;
            cv.notify_one();
        }
    });
    th1.join();
    th2.join();
    return 0;
}

C++11 核心特性：可变参数模板、Lambda 与线程库

九、可变参数模板

十、lambda 表达式

10.1 C++98 中的一个例子

10.2 lambda 表达式

10.3 lambda 表达式语法

10.3.1 lambda 表达式各部分说明

10.3.2 捕获列表说明

10.4 函数对象与 lambda 表达式

十一、包装器

11.1 function 包装器

11.2 bind

十二、线程库

12.1 线程

12.1.1 thread 类的简单介绍

12.1.2 thread 类中常用函数

12.1.2.1 构造函数

12.1.2.2 移动拷贝

12.1.2.3 thread::get_id 函数 与 this_thread::get_id 函数

12.1.2.4 joinable 函数

12.1.2.5 join 函数

12.1.2.6 detach 函数

12.1.2.7 swap 函数

12.2 锁

12.2.1 锁的简单介绍

12.2.2 mutex 中常用的接口及应用

12.2.2.1 lock 函数

12.2.2.2 try_lock 函数

12.2.2.3 unlock 函数

12.2.2.4 接口的使用

12.2.3 lock_guard 类

12.2.4 unique_lock 类

12.3 条件变量

12.3.1 条件变量的简单介绍

12.3.2 condition_variable 的中常用的接口

12.3.2.1 wait 函数

12.3.2.2 notify_one 函数

12.4 综合应用（支持两个线程交替打印，一个打印奇数，一个打印偶数）

12.5 原子操作

12.5.1 atomic 类 的简单介绍

12.5.2 atomic 类 的简单使用

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

12.1.2.3 thread::get_id 函数与 this_thread::get_id 函数

12.5.1 atomic 类的简单介绍

12.5.2 atomic 类的简单使用