C++11 新特性系列（二）：初始化与空指针的现代化

本系列第二篇，我们聚焦 C++11 在初始化和空指针方面的革命性改进。统一初始化语法终结了以往混乱的初始化方式，而nullptr则彻底告别了 NULL 带来的二义性噩梦。一起看看这些改变如何让代码更安全、更一致。

从“百花齐放”到“一统天下”：初始化方式的演进

在 C++98/03 中，初始化一个变量或对象，你有至少四种不同的写法，具体用哪个取决于类型和上下文：

inta=10;// 赋值初始化intb(10);// 构造函数初始化intc={10};// 列表初始化（仅对 POD 和数组）intd{10};// 直接列表初始化（C++98 对聚合体有效）

对于类对象，更是一片混乱：

std::vector<int>v1(10,5);// 10 个 5std::vector<int>v2={1,2,3};// 在 C++98 中编译错误！没有 initializer_listintarr[]={1,2,3};// 只能用列表初始化数组structPoint{intx,y;};Point p={1,2};// 聚合体初始化Point q{3,4};// 也可以

更让人头疼的是，std::vector<int>(10, 5)和std::vector<int>{10, 5}的意义完全不同——前者是 10 个 5，后者是包含 10 和 5 两个元素的 vector。这种不一致性容易导致误用和 bug。

C++11 引入统一初始化（uniform initialization），即使用花括号{}初始化一切，让语法变得一致，同时提供了std::initializer_list支持自定义类型的列表构造。

与此同时，空指针的表示也长期存在隐患——NULL通常被定义为0或(void*)0，在重载场景下会导致二义性，甚至被误当作整数。C++11 引入nullptr彻底解决了这个问题。

一、统一初始化语法（列表初始化）

1.1 基本用法：一切皆可{}

C++11 允许使用花括号{}来初始化任何类型的变量，无论是内置类型、数组、聚合体还是类对象：

// 内置类型inta{10};// 等价于 int a = 10;doubleb{3.14};charc{'A'};// 数组intarr[]{1,2,3,4};// 标准库容器std::vector<int>vec{1,2,3,4,5};std::map<std::string,int>scores{{"Alice",95},{"Bob",87}};// 自定义类（聚合体）structPoint{intx;inty;};Point p{10,20};// 自定义类（带构造函数的类）classMyClass{public:MyClass(inta,doubleb):m_a(a),m_b(b){}private:intm_a;doublem_b;};MyClass obj{42,3.14};// 调用构造函数

甚至可以用{}进行动态内存分配：

int*p=newint{100};std::vector<int>*vp=newstd::vector<int>{1,2,3};

1.2 防止窄化转换（Narrowing Conversion）

统一初始化最实用的特性之一是禁止窄化转换（narrowing conversion）。所谓窄化，是指隐式转换导致精度丢失或范围缩小的情形。

inta=3.14;// 传统方式：警告但允许，a 变成 3intb{3.14};// 错误！窄化转换，编译不通过charc1=1000;// 允许（可能溢出）charc2{1000};// 错误！窄化转换（1000 超出 char 范围）doubled=0;int*p=d;// 错误，但有些编译器只警告int*q{d};// 错误！窄化转换（double 到指针）

这个特性在初始化大型对象或模板时尤其有用，因为它能在编译期捕获意外的精度损失，让代码更健壮。

1.3 初始值设定（空列表）

使用空{}可以值初始化（value-initialize）变量，对于内置类型，这会将它们清零：

inta{};// a = 0doubleb{};// b = 0.0int*p{};// p = nullptr（注意，不是 NULL）structS{intx;doubley;};S s{};// s.x = 0, s.y = 0.0std::vector<int>vec{};// 空 vector

这提供了一种安全、简洁的零初始化方式，避免了未初始化变量的风险。

二、std::initializer_list：支持列表初始化的类

2.1 什么是 initializer_list？

要想让自定义类型也支持像std::vector<int>{1,2,3}这样的列表初始化，需要用到std::initializer_list<T>。这是一个轻量级的代理类，表示一个由编译器自动构建的临时数组。

类可以提供一个接受std::initializer_list参数的构造函数，或者使用=重载赋值运算符接受它。

2.2 实现一个支持列表初始化的类

#include<iostream>#include<initializer_list>#include<vector>classMyArray{public:// 接受 initializer_list 的构造函数MyArray(std::initializer_list<int>list){for(autoit=list.begin();it!=list.end();++it){data.push_back(*it);}}// 也可以重载赋值运算符MyArray&operator=(std::initializer_list<int>list){data.clear();for(autoelem:list){data.push_back(elem);}return*this;}voidprint()const{for(intval:data)std::cout<<val<<" ";std::cout<<std::endl;}private:std::vector<int>data;};intmain(){MyArray arr1{1,2,3,4};// 调用构造函数arr1.print();// 1 2 3 4MyArray arr2={5,6,7};// 也 OK（构造）arr2.print();// 5 6 7arr1={8,9};// 调用赋值运算符arr1.print();// 8 9return0;}

2.3 优先匹配规则

当一个类既有普通构造函数，又有initializer_list构造函数时，如果使用{}初始化，编译器会优先匹配initializer_list版本：

classFoo{public:Foo(inta,intb){std::cout<<"Foo(int,int)\n";}Foo(std::initializer_list<int>){std::cout<<"Foo(initializer_list)\n";}};Foo f1{1,2};// 调用 initializer_list 版本（输出 Foo(initializer_list)）Foof2(1,2);// 调用普通构造函数（输出 Foo(int,int)）

这解释了为什么std::vector<int>{10, 5}表示两个元素，而std::vector<int>(10, 5)表示 10 个 5——因为{}触发了initializer_list构造函数。

陷阱：如果initializer_list构造函数的参数类型可以匹配，它会“劫持”初始化，即使这看起来像是用两个整数构造：

Foo f3{10};// 如果 Foo 有 Foo(int) 和 Foo(initializer_list<int>)，则调用后者（用 {10} 构造 initializer_list）

所以设计类时需注意：如果提供了initializer_list构造函数，要确保它与其他构造函数的语义不冲突。

三、nullptr：真正的空指针

3.1 NULL 的痛点

在 C++98 中，NULL通常被定义为0（某些实现为(void*)0，但 C++ 不允许隐式转换void*到其他指针类型，所以大多数实现用0）。这就带来了几个问题：

问题1：二义性重载

voidfunc(int){std::cout<<"int\n";}voidfunc(char*){std::cout<<"char*\n";}func(NULL);// 调用 int 版本！因为 NULL 是 0

程序员的本意往往是调用指针版本，结果却调用了整数版本，而且编译器不会报错，容易产生隐蔽的逻辑错误。

问题2：在模板中误判为整数

template<typenameT>voidprocess(T*ptr){/* ... */}process(NULL);// 推导 T = int？ 错误！NULL 是 int，无法作为指针参数

问题3：0本身作为整数常量，在类内初始化时语义模糊

3.2 nullptr 的本质

C++11 引入nullptr，它是一个空指针常量，类型是std::nullptr_t（定义在<cstddef>）。nullptr可以隐式转换为任何指针类型和成员指针类型，但不能转换为整数类型（除了bool）。

int*p1=nullptr;// OKchar*p2=nullptr;// OKvoid*p3=nullptr;// OKint(MyClass::*pmf)()=nullptr;// OK（成员函数指针）inti=nullptr;// 错误！不能转换为整数

nullptr与0的比较：

if(ptr==nullptr){/* ... */}// 清晰意图if(ptr==0){/* ... */}// 较不清晰

3.3 解决重载二义性

有了nullptr，上面的重载示例会正确调用指针版本：

voidfunc(int){std::cout<<"int\n";}voidfunc(char*){std::cout<<"char*\n";}func(nullptr);// 调用 char* 版本func(0);// 调用 int 版本（0 是 int 字面量）

3.4 std::nullptr_t

如果需要存储或传递nullptr，可以使用std::nullptr_t类型：

#include<cstddef>voidlog(std::nullptr_t){std::cout<<"Got nullptr\n";}intmain(){log(nullptr);// OK// log(0); // 错误std::nullptr_t np=nullptr;int*p=np;// OK：隐式转换return0;}

注意：不要重载std::nullptr_t版本与其他指针类型，否则也会导致二义性，因为nullptr可转换为任何指针，编译器无法区分。

四、=default 与 =delete：控制默认函数

4.1 特殊成员函数的自动生成

在 C++98 中，如果用户没有声明，编译器会为类自动生成默认构造函数、拷贝构造函数、拷贝赋值运算符和析构函数。但一旦用户自定义了任一构造函数，默认构造函数就不再自动生成。这一规则有时会造成困扰。

C++11 引入了=default和=delete，让程序员显式控制这些特殊成员函数的生成。

4.2 =default：显式要求生成默认版本

=default告诉编译器：请使用默认实现。

classWidget{public:Widget()=default;// 显式生成默认构造函数Widget(constWidget&)=default;// 显式生成拷贝构造函数Widget&operator=(constWidget&)=default;// 显式生成拷贝赋值// 或者简写：只需声明即可，编译器会生成~Widget()=default;};

适用场景：

• 当你需要自定义某个构造函数，但仍希望保留默认构造函数时。
• 当你因为某些原因（如定义了移动构造函数）导致拷贝构造函数被抑制，但你仍希望保留它们时（注意移动构造会抑制拷贝构造，但可以用=default恢复）。
• 期望获得比手写版本更好的性能（编译器默认实现可能更高效）。

示例：

classMyClass{public:MyClass(intx):m_x(x){}// 自定义构造函数MyClass()=default;// 仍然保留默认构造函数private:intm_x;};MyClass a;// OK，使用默认构造MyClassb(10);// OK，使用自定义构造

4.3 =delete：禁止特定函数

=delete让程序员显式删除某个函数，使得任何试图调用它的代码都会在编译期报错。它比将函数声明为private且不实现的方式更彻底（后者在链接期报错，且信息不友好）。

classNonCopyable{public:NonCopyable()=default;NonCopyable(constNonCopyable&)=delete;// 禁止拷贝构造NonCopyable&operator=(constNonCopyable&)=delete;// 禁止拷贝赋值};NonCopyable a;// NonCopyable b(a); // 错误！拷贝构造被删除// NonCopyable c; c = a; // 错误！拷贝赋值被删除

可以删除任意函数，不仅限于特殊成员：

voidfunc(int){/* ... */}voidfunc(double)=delete;// 禁止调用 double 版本func(10);// OK// func(3.14); // 错误！删除函数

还可以删除模板特化：

template<typenameT>voidprocess(T){/* ... */}template<>voidprocess<void>(void)=delete;// 禁止对 void 的调用

删除析构函数可以阻止栈上对象创建（但需要结合动态内存管理）：

classSingleton{public:staticSingleton&getInstance(){staticSingleton instance;returninstance;}Singleton(constSingleton&)=delete;Singleton&operator=(constSingleton&)=delete;private:Singleton()=default;~Singleton()=delete;// 禁止外部 delete};// 需要谨慎使用，通常不推荐删除析构函数

4.4 移动语义对默认函数的影响（简要提及）

在 C++11 中，如果用户声明了移动构造函数或移动赋值运算符，那么拷贝构造函数和拷贝赋值运算符会被隐式删除。如果仍需要它们，可以使用=default恢复。这涉及到移动语义，我们将在系列第四篇详细讲解。

综合示例

将所有新特性融合在一个场景中：一个支持列表初始化的智能数组类，并且禁止拷贝，仅支持移动（移动语义后续会讲，这里先展示 =delete 和 =default 的运用，以及 initializer_list）。

#include<iostream>#include<initializer_list>#include<algorithm>classIntArray{public:// 使用 initializer_list 构造IntArray(std::initializer_list<int>list):m_size(list.size()),m_data(newint[list.size()]){std::copy(list.begin(),list.end(),m_data);std::cout<<"Constructed from initializer_list\n";}// 默认构造IntArray():m_size(0),m_data(nullptr){}// 析构~IntArray(){delete[]m_data;}// 禁止拷贝（但允许移动，移动语义后面会讲，这里先占位）IntArray(constIntArray&)=delete;IntArray&operator=(constIntArray&)=delete;// 允许默认移动（C++11 自动生成，但前提是未声明拷贝构造，这里我们显式声明了 =delete，所以移动也会被抑制，需要显式 =default）// 但为了演示，我们暂时不展开移动，只是说明 =delete 的用法voidprint()const{for(size_t i=0;i<m_size;++i)std::cout<<m_data[i]<<" ";std::cout<<std::endl;}private:size_t m_size;int*m_data;};intmain(){// 统一初始化inta{42};int*p{nullptr};// 使用 initializer_list 构造IntArray arr{1,2,3,4,5};arr.print();// 1 2 3 4 5// IntArray arr2 = arr; // 错误！拷贝构造被删除// 使用 nullptrif(p==nullptr){std::cout<<"p is null\n";}return0;}

常见陷阱与最佳实践

陷阱1：{}初始化与initializer_list的偏好

如前所述，{}会优先匹配initializer_list构造函数，这可能导致意外行为：

std::vector<int>v1{10,5};// 两个元素：10 和 5std::vector<int>v2(10,5);// 10 个 5

在设计类时，如果要避免这种歧义，可以提供initializer_list构造函数，但也要确保其他构造函数的使用方式清晰。

陷阱2：auto与{}的交互

auto与{}结合时，推导结果可能出乎意料：

autox1{10};// 在 C++11 中推导为 std::initializer_list<int>？// 实际上，C++11 中 auto 用 {} 初始化会推导为 initializer_list（但有歧义）// 自 C++17 起，规则改变为推导为 int。// 本系列基于 C++11，建议避免用 auto x = {10}; 这样的写法。

更好的做法是：用auto时，尽量用=或()初始化，而非{}，以避免歧义。或者明确使用auto x = 10;。

陷阱3：nullptr与bool的转换

nullptr可以隐式转换为bool，因此在条件表达式中可以用：

if(ptr){/* ... */}// ptr 是 nullptr 则为 false

但这不意味着nullptr可以参与算术运算，它本质上是空指针常量。

最佳实践总结

• 优先使用{}初始化，尤其是对于容器和聚合体，但注意与initializer_list构造函数的优先级。
• 使用nullptr替代NULL和0表示空指针。
• 使用=default生成默认特殊成员，让编译器优化。
• 使用=delete明确禁止不需要的函数，尤其是拷贝和移动操作，这比private声明更优雅、更安全。
• 对于类，遵循“三五法则”（如果定义了析构函数、拷贝构造函数或拷贝赋值运算符中的任何一个，通常需要定义所有三个；在 C++11 后还需考虑移动），利用=default/=delete来显式控制。

总结

这一篇的内容让 C++ 的初始化行为和空指针语义变得现代化、一致化且更安全。它们看似简单，却在日常编码中频繁使用，深刻影响着代码的可读性和健壮性。

下一篇预告：我们将探讨让代码更清晰的语法糖，包括范围for循环、override/final关键字、委托构造函数和继承构造函数。这些特性将进一步简化类继承和循环代码，让 C++ 更加易用。敬请期待！