前言如果把 C 的历史分成两段那么 2011 年发布的 C11原名 C0x就是那条分界线。在此之前C 被戏称为带类的 CC with Classes写一个能用的类要手写构造、析构、拷贝构造、拷贝赋值四件套想给sort传一个自定义比较规则只能在外层定义一个函数或者写一个函数对象类想保存任意可调用物只能靠函数指针或者臃肿的继承体系。C11 一次性把这些问题全解决了它引入了三类能力正好对应本文的三个主题类的新功能 default/ delete、override/final、委托构造、继承构造、类内成员初始化NSDMI、explicit转换运算符。它们让类的意图可以被写进代码而不是写在注释里。lambda 表达式把一小段行为变成可以在调用点就地书写的表达式编译器为它生成一个匿名的函数对象类。包装器std::function、std::bind、std::reference_wrapper、std::mem_fn把各种形态的可调用物统一成一种类型。本文不满足于罗列语法而是重点讲清楚三件事编译器在背后生成了什么、为什么这么设计、以及实际写代码时最容易掉进去的坑。一、为什么 C11 要动类的语法先看一段 C98 时代的典型代码。class Buffer { public: Buffer() : data_(nullptr), size_(0) {} Buffer(const Buffer rhs) : data_(new char[rhs.size_]), size_(rhs.size_) { std::memcpy(data_, rhs.data_, size_); } Buffer operator(const Buffer rhs) { if (this ! rhs) { // 必须自己防自赋值 char* tmp new char[rhs.size_]; std::memcpy(tmp, rhs.data_, rhs.size_); delete[] data_; data_ tmp; size_ rhs.size_; } return *this; } ~Buffer() { delete[] data_; } private: char* data_; size_t size_; };这段代码里有三个人肉编译器的痕迹operator里的自赋值检查写了不一定对不写就可能先delete掉自己的数据再memcpy直接 UB。明明这个类不应该被拷贝比如它持有的是独占资源却因为不写就等于编译器帮你生成而必须写一堆代码来禁用拷贝。派生类想复用基类构造函数只能一个个手写转发。C11 的类新功能就是在消除这些痕迹。二、类的新功能逐项拆解2.1 default与 delete default告诉编译器按默认规则生成但我要显式地把它列出来 delete告诉编译器这个函数存在但被删除了任何调用都是编译错误。class NonCopyable { public: NonCopyable() default; NonCopyable(const NonCopyable) delete; NonCopyable operator(const NonCopyable) delete; virtual ~NonCopyable() default; };为什么要用 delete而不是private且不实现C98 的惯用法是把拷贝构造声明为private且只声明不定义这样类外调用报访问权限错误类内或友元调用则在链接期报未定义符号。这个错误信息又晚又难懂。 delete把错误提前到了编译期并且错误信息直白得多error: use of deleted function NonCopyable::NonCopyable(const NonCopyable)一个容易被忽略的细节 delete可以作用于任意函数不限于成员函数。这是 C11 提供的一个重载拦截利器// 禁止用 double 调用防止隐式窄化 void process(int value); void process(double) delete; process(42); // OK process(3.14); // 编译错误use of deleted function另一个关键点 default用在类内时默认构造函数的成员初始化依赖 NSDMI 的顺序而 default写在类外定义处会让这个类不再是聚合类型aggregate也不能用于constexpr上下文中的某些场景——这是后面坑点章节会展开的内容。2.2override与finalclass Base { public: virtual void run(int speed) const; virtual ~Base() default; }; class Derived : public Base { public: void run(int speed) override; // ❌ 编译错误缺少 const没有覆盖任何函数 void stop() final; // 本类之后不能再被覆盖 };override的价值在于把运行期静默错误变成编译期错误。如果不写override上面那个漏掉const的run会是一个全新的虚函数它安静地和基类版本共存多态调用Base*-run()时永远走不到它。这类 bug 在大型项目里极难定位因为一切看起来都对。final有两个用法修饰虚函数表示到此为止修饰类表示这个类不能被继承。后者给编译器留了优化空间——编译器知道final类的虚函数不会被后续覆盖可以做去虚化devirtualization把间接调用变成直接调用甚至内联。2.3 委托构造Delegating Constructorclass Connection { public: Connection() : Connection(localhost, 8080) {} // 委托给下面的构造函数 Connection(std::string host) : Connection(std::move(host), 8080) {} Connection(std::string host, int port) : host_(std::move(host)), port_(port) {} // 真正的目标构造函数 private: std::string host_; int port_; };规则只有一条委托构造的初始化列表里只能有那一个委托目标不能同时初始化成员。一旦你把host_和委托目标写在一起编译器就报错error: mem-initializer for host_ follows constructor delegation这条规则背后的原因是对象的构造顺序C 保证基类 → 成员 → 构造函数体。委托构造实际上是让目标构造函数完整地跑一遍包括它自己的基类和成员初始化所以委托方自己不能再去碰成员否则就会出现同一成员被初始化两次的语义混乱。工程价值它消灭了公共初始化代码抽成一个init()函数这种反模式。init()的问题在于它不是构造函数对象在init()之前处于半成品状态而且派生类里调用虚函数会失效。2.4 继承构造Inheriting Constructorstruct Base { Base(int a) { /* ... */ } Base(int a, int b) { /* ... */ } }; struct Derived : Base { using Base::Base; // 把 Base 的所有构造函数拉进来 }; Derived d1(1); // OK等价于 Derived(int a) : Base(a) {} Derived d2(1, 2); // OK一行using Base::Base省掉了所有转发构造。它不继承什么这是很容易被误解的地方不继承默认构造函数基类的默认构造在派生类中需要自己生成。不继承拷贝/移动构造函数。如果派生类自己定义了构造函数继承来的构造函数不会与它冲突但派生类的成员初始化不会发生——继承构造只完成基类部分的初始化派生类自己的成员走的是默认初始化可能有 NSDMI。最后一点是最阴的坑后面会详细说。2.5 类内成员初始化NSDMI, Non-Static Data Member Initializerclass Config { int timeout_ 30; // NSDMI std::string name_ default; // NSDMI std::vectorint cache_{}; // 空列表也是 NSDMI public: Config() default; // 自动使用 NSDMI Config(int t) : timeout_(t) {} // 覆盖 timeout_name_ 仍用 NSDMI };NSDMI 让默认值和声明放在一起不用再在构造函数初始化列表里重复一遍。它的实现机制编译器把 NSDMI 视为当构造函数初始化列表中没有显式初始化该成员时插入到列表中的初始化器。所以它的执行时机和普通初始化列表完全一致基类 → 成员按声明顺序→ 构造函数体。2.6explicit转换运算符class Bool { public: explicit operator bool() const { return value_ ! 0; } private: int value_ 0; }; Bool b; if (b) {} // OK条件上下文允许 explicit 转换 bool x b; // ❌ 编译错误不允许隐式转换 int y b 1; // ❌ 编译错误不再隐式变成 int 参与算术C98 里operator bool不能加explicit于是safe bool idiom返回一个成员函数指针成了标准绕路方案。C11 的explicit operator bool让if (obj)、while (obj)、!obj这些语境转换contextual conversion依然可用但阻断了int n obj;这种危险的隐式转换。三、lambda 表达式编译器替你写了什么3.1 语法拆解[capture](parameters) mutable - return_type { body } // ^ ^ ^ ^ ^ // 捕获列表 参数列表 可变规格 返回类型 函数体一个最简单的例子int threshold 10; auto is_big [threshold](int x) { return x threshold; };编译器会生成一个和下面大致等价的闭包类型closure typeclass __Lambda_1 { int threshold; // 捕获的变量变成成员 public: __Lambda_1(int t) : threshold(t) {} bool operator()(int x) const { // 注意是 const 成员函数 return x threshold; } };理解了lambda 是函数对象类的语法糖很多行为就自然说得通了。3.2 捕获列表capture list写法含义说明[]不捕获只能访问全局/静态变量[x]按值捕获 x捕获那一刻的副本[x]按引用捕获 x引用的是原变量[]按值捕获所有用到的隐式捕获[]按引用捕获所有用到的隐式捕获[this]捕获当前对象指针C20 起可用[this, *this][x expr]初始化捕获init-captureC14可移动捕获一个必须记住的规则按值捕获是在 lambda 被创建的那一刻完成拷贝而不是在调用时。也就是说下面这段代码输出的是10不是20int x 10; auto f [x] { return x; }; x 20; std::cout f(); // 输出 10而按引用捕获会跟着变同时也带来了悬垂引用dangling reference的风险。3.3mutable与不可变闭包默认情况下 lambda 的operator()是const的所以按值捕获的成员在函数体内不可修改int count 0; auto f [count]() mutable { return count; }; // 没有 mutable 就是编译错误这里有个反直觉的点mutable修改的是闭包对象的副本不是外部的count。这恰恰和很多人以为的按引用才能改相反——按值捕获配mutable也是能改的只是改的是自己的副本。3.4 返回类型推导如果函数体只有一个return语句返回类型自动推导如果有多个return且类型不一致必须显式写- Tauto f [](int x) { return x * 1.0; }; // 返回 double auto g [](int x) - double { // 多 return 必须显式 if (x 0) return x; return 0.0; };四、包装器把可调用物统一起来4.1std::functionstd::function是类型擦除type erasure的容器它能装下任何签名兼容的可调用物——函数指针、lambda、函数对象、成员函数绑定结果。#include functional #include iostream int add(int a, int b) { return a b; } struct Mul { int operator()(int a, int b) const { return a * b; } }; int main() { std::functionint(int, int) f; f add; // 函数指针 std::cout f(2, 3) \n; // 5 f Mul{}; // 函数对象 std::cout f(2, 3) \n; // 6 f [](int a, int b) { return a - b; }; // lambda std::cout f(2, 3) \n; // -1 }代价std::function通常有一个小对象优化SOO, small object optimization能装下小对象就放在内部缓冲区装不下就堆分配。同时operator()是虚调用形态的间接调用无法内联。所以它适合回调注册这类边界场景不适合放进热点循环。4.2std::bind与std::placeholdersusing namespace std::placeholders; int sub(int a, int b) { return a - b; } auto f1 std::bind(sub, 10, _1); // f1(x) 10 - x auto f2 std::bind(sub, _1, 10); // f2(x) x - 10 auto f3 std::bind(sub, _2, _1); // f3(x, y) y - xstd::bind还有两个实用的能力绑定成员函数和重排参数。struct Widget { void draw(int layer) const { std::cout layer layer \n; } }; Widget w; auto drawer std::bind(Widget::draw, w, _1); // 绑定 this 指针 drawer(3);重要建议C11 之后的代码里std::bind的绝大多数用途都可以用 lambda 更清晰地表达而且 lambda 的性能更好不涉及bind的转发开销、更容易内联auto drawer [w](int layer) { w.draw(layer); }; // 更推荐std::bind仍然值得用的场景主要是泛型代码中需要std::bind作为参数传递或者需要把可调用物和参数一起存储起来延迟调用。4.3std::reference_wrapper与std::ref/std::cref这是 C11 里最容易被忽略、但最有用的小工具之一。它的存在是为了解决标准库按值拷贝但我想传引用的矛盾。void inc(int x) { x; } int a 1; // std::bind(inc, a)(); // ❌ 编译错误bind 按值存 a得到的是 int 而非 int std::bind(inc, std::ref(a))(); // ✅ 用 reference_wrapper 保存引用 std::cout a; // 2另一个经典场景是容器std::vectorint data{1, 2, 3}; std::vectorstd::reference_wrapperint refs(data.begin(), data.end()); refs[0].get() 100; // 通过 .get() 拿到原对象引用 std::cout data[0]; // 100注意std::vectorint是非法的标准容器不能存引用reference_wrapper就是绕开这条限制的标准做法。4.4std::mem_fnstd::mem_fn把成员函数指针变成一个可调用对象比bind更轻量struct Item { int value; int get() const { return value; } }; std::vectorItem items{{1}, {2}, {3}}; auto getter std::mem_fn(Item::get); std::cout getter(items[1]); // 2五、代码实战一个可配置的任务调度器完整可编译下面把本文涉及的特性综合起来写一个完整可编译的例子。// scheduler.cpp — g -stdc11 scheduler.cpp -o scheduler #include functional #include iostream #include string #include vector #include algorithm class Task { public: using Callback std::functionvoid(int); Task() default; Task(std::string name, Callback cb) // 委托给下面 : Task(std::move(name), std::move(cb), 0) {} Task(std::string name, Callback cb, int priority) : name_(std::move(name)) , cb_(std::move(cb)) , priority_(priority) {} Task(const Task) delete; // 明确禁止拷贝 Task operator(const Task) delete; Task(Task) default; // 允许移动 Task operator(Task) default; void run(int arg) const { if (cb_) cb_(arg); } int priority() const { return priority_; } const std::string name() const { return name_; } private: std::string name_ unnamed; // NSDMI Callback cb_ nullptr; // NSDMI int priority_ 0; // NSDMI }; class Scheduler { public: void add(Task t) { tasks_.push_back(std::move(t)); } void runAll(int arg) { // lambda 作为比较器按值捕获局部副本 int pivot 5; std::sort(tasks_.begin(), tasks_.end(), [pivot](const Task a, const Task b) { // 优先级 pivot 的排在前面 bool ap a.priority() pivot; bool bp b.priority() pivot; if (ap ! bp) return ap; return a.priority() b.priority(); }); for (const auto t : tasks_) { std::cout [ t.name() ] ; t.run(arg); } } private: std::vectorTask tasks_; }; int main() { Scheduler sched; int counter 0; sched.add(Task(low, [counter](int x) { counter x; std::cout counter counter \n; }, 1)); sched.add(Task(high, [counter](int x) { counter x * 10; std::cout counter counter \n; }, 9)); sched.add(Task(mid, [](int x) { std::cout noop x \n; }, 5)); sched.runAll(2); std::cout final counter counter \n; return 0; }这个小例子覆盖了 default/ delete、委托构造、NSDMI、std::function作为成员、lambda 按值捕获比较器与按引用捕获counter、以及移动语义在容器中的使用。编译运行输出顺序为high→mid→low。常见坑点坑点 1按引用捕获局部变量并在 lambda 逃逸后调用❌ 错误写法std::functionvoid() makeCallback() { int local 42; return [local] { std::cout local \n; }; // ❌ local 已销毁 } int main() { auto cb makeCallback(); cb(); // 未定义行为UB读取已销毁的栈变量 }这段代码能编译通过甚至可能看起来正常因为栈内存还没被覆盖。这是最危险的一类 UB。✅ 正确写法std::functionvoid() makeCallback() { int local 42; return [local] { std::cout local \n; }; // ✅ 按值捕获拷贝进闭包 }如果对象很大不想拷贝用初始化捕获把所有权移进去auto cb [data std::move(bigData)] { use(data); };坑点 2std::bind的按值语义吃掉引用参数❌ 错误写法void process(std::string s); // 内部要修改 s std::vectorstd::string names{a, b}; std::for_each(names.begin(), names.end(), std::bind(process, _1)); // ❌ 编译错误std::bind会把_1指代的实参按值存进内部 tuple最终把一个std::string右值/临时量传给需要std::string的函数。✅ 正确写法std::for_each(names.begin(), names.end(), std::bind(process, std::ref(_1))); // ✅ 用 reference_wrapper 保留引用 // 更推荐直接用 lambda std::for_each(names.begin(), names.end(), [](std::string s) { process(s); });坑点 3 delete与重载决议的交互——删掉的函数仍然参与重载❌ 错误写法void log(const char* msg); void log(bool) delete; log(hello); // ✅ 走 const char* log(nullptr); // ❌ 编译错误删除了 log(bool)很多人以为删掉的重载不存在其实它存在于重载集合并参与决议只是被选中后报错。这正是它能用来拦截隐式转换的原因。反过来如果你想要的是这个参数组合不参与重载应该用 SFINAE 而不是 delete。坑点 4继承构造不初始化派生类成员❌ 错误写法struct Base { Base(int) {} }; struct Derived : Base { using Base::Base; // 继承 Base(int) int extra_ 0; }; Derived d(5); // extra_ 用 NSDMI 初始化0看似没问题真正的坑在没有 NSDMI 的成员struct Derived2 : Base { using Base::Base; int raw_; // 没有 NSDMI }; Derived2 d(5); // raw_ 是默认初始化 → 对 int 而言是不确定值 int v d.raw_; // ❌ UB读取未初始化的 int✅ 正确写法给所有成员加 NSDMI或者显式写一个构造函数struct Derived3 : Base { using Base::Base; int raw_ 0; // ✅ NSDMI 兜底 };坑点 5std::function的额外分配与空调用class Widget { std::functionvoid() onClick_; public: void setOnClick(std::functionvoid() cb) { onClick_ std::move(cb); } void click() { if (onClick_) onClick_(); } // 必须判空 };两个要点std::function默认构造后是空的调用它抛std::bad_function_call不是 UB但也绝不是你想要的行为。所以调用前一定判空if (onClick_)。性能std::function的对象大小通常在 32 字节左右libstdc 的实现里内部缓冲区 16 字节。捕获量大的 lambda 会触发堆分配。若回调在热路径上考虑用模板参数或函数指针替代std::function。坑点 6lambda 捕获this时的对象生命周期❌ 错误写法class Widget { int value_ 0; public: std::functionint() getter() { return [this] { return value_; }; // ❌ 捕获了 this 指针 } }; Widget w; auto g w.getter(); // w 销毁后… // g(); // UBthis 悬垂✅ 正确写法C11 里最稳妥的是按值捕获所需数据std::functionint() getter() { int v value_; return [v] { return v; }; // ✅ 捕获值的副本 }C14 之后可以用[*this]C17 正式按值捕获整个对象。坑点 7NSDMI 与聚合初始化C11 中带 NSDMI 的类不再是聚合类型aggregate不能再用花括号聚合初始化struct Point { int x 0; int y 0; }; Point p{1, 2}; // ❌ C11 中编译错误Point 不是聚合类型这条限制在C14 被放宽N3653主流编译器现在都接受。如果你的构建链还停留在-stdc11且代码用了 NSDMI这一点值得注意。另外C14 的放宽是有条件的只有当 NSDMI 不引用其它成员、不使用花括号初始化列表时聚合性才保留。总结特性解决的核心问题关键记忆点 default/ delete显式表达用默认或禁止 delete可作用任意函数且仍参与重载决议override/final虚函数覆盖错误从运行期提前到编译期final还能帮助编译器去虚化委托构造消除init()反模式委托方初始化列表里不能再列成员继承构造消除转发构造样板不初始化派生类自己的成员NSDMI默认值声明即定义执行顺序仍按声明顺序C11 下破坏聚合性explicit operator bool安全的条件转换语境转换仍可用隐式转换被阻断lambda就地书写行为它是闭包类按值捕获是创建时拷贝std::function类型擦除的可调用容器有空状态、可能堆分配、不能内联std::bind参数绑定与重排默认按值存储需引用用std::refstd::reference_wrapper让标准库容器/算法持有引用容器不能存引用用它包装C11 的这三个方向有一个共同的哲学把意图显式化。代码不再依赖编译器帮你生成的默认行为里的隐含假设而是把我要移动我要禁止拷贝我要覆盖直接写出来。理解了这一层你就能明白为什么 C11 之后的代码即使看起来更啰嗦却比 C98 更难写错。