值初始化(C++03 起)

来自cppreference.com
< cpp‎ | language
 
C++
 
C++ 语言
 
初始化
 

这是在以空初始化器构造对象时进行的初始化。

语法

T() (1)
new T () (2)
类::类(...) : 成员() { ... } (3)
T 对象 {}; (4) (C++11 起)
T{} (5) (C++11 起)
new T {} (6) (C++11 起)
类::类(...) : 成员{} { ... } (7) (C++11 起)

解释

以下场合进行值初始化：

1,5) 当以空的括号或花括号 (C++11 起)对组成的初始化器创建无名临时对象时；
2,6) 当 new 表达式以空的括号或花括号 (C++11 起)对组成的初始化器创建具有动态存储期的对象时；
3,7) 当使用以空的括号或花括号 (C++11 起)对组成的成员初始化器初始化非静态数据成员或基类时；
4) 当以由空花括号对组成的初始化器声明具名对象（自动、静态或线程局部）时。
 (C++11 起)

所有情况下，如果使用空花括号对 {} 且 T 是聚合类型，则进行聚合初始化而非值初始化。

如果 T 是没有默认构造函数但带有接受 std::initializer_list 的构造函数的类类型，则进行列表初始化。

(C++11 起)


值初始化的效果是：

1) 如果 T 是拥有至少一个用户提供的任意种类的构造函数的类类型，则调用默认构造函数；
2) 如果 T 是没有任何用户提供的构造函数的非联合体类类型，则值初始化 T 的每个非静态数据成员与基类组分；
(C++11 前)
1) 如果 T 是没有默认构造函数，或拥有用户提供的或被删除的默认构造函数的类类型，则对象被默认初始化；
2) 如果 T 是拥有默认构造函数的类类型，而默认构造函数既没有被用户提供也没有被删除（即它可以是拥有隐式定义的或默认化的默认构造函数的类），则零初始化对象，然后如果它拥有非平凡的默认构造函数，则默认初始化它；
然而在重载决议选择未被删除的默认化的默认构造函数时，所有已知编译器都进入情况 (2)，即使有用户提供的默认构造函数，见注解；
(C++11 起)
3) 如果 T 是数组类型，则值初始化数组的每个元素；
4) 否则，零初始化对象。

注解

如果构造函数是用户声明的，且未在其首个声明上显式默认化，则它是用户提供的。

语法 T object(); 不初始化对象；它声明一个不接受参数并返回 T 的函数。在 C++11 前值初始化一个具名变量的方式是 T object = T();，它值初始化一个临时量然后复制初始化该对象：多数编译器在此情况下能优化掉复制。

在 C++03（引入了值初始化）之前的 C++98 中，表达式 new T() 被归类为默认初始化并指定进行零初始化。

引用不能被值初始化。

如函数式转型中所述，数组禁止语法 T() (1) ，但允许 T{} (5)。

所有标准容器（std::vector、std::list 等）在以单个 size_type 实参进行构造或由对 resize() 的调用而增长时值初始化其各个元素，除非其分配器定制 construct 的行为。

从 C++11 起，对没有用户提供的构造函数而拥有类类型成员的类进行值初始化，其中成员的类拥有用户提供的构造函数，会在调用成员的构造函数前对成员清零： 

struct A
{
    int i;
    A() { } // 用户提供的默认构造函数，不初始化 i
};
 
struct B { A a; }; // 隐式定义的默认构造函数
 
std::cout << B().a.i << '\n'; // 值初始化 B 临时量
                              // C++03 中令 b.a.i 为未初始化
                              // C++11 中设 b.a.i 为零
// （注意 C++11 中 B{}.a.i 保留 b.a.i 为未初始化，但因为不同原因：
// 在 DR1301 后的 C++11 中，B{} 是聚合初始化，它值初始化拥有用户提供构造函数的 A）

标准指定在类拥有用户提供的或被删除的默认构造函数时不进行零初始化，即使重载决议不选择该默认构造函数。所有已知编译器都在选择未被删除的默认化的默认构造函数时进行额外的零初始化。 

struct A {
    A() = default;
    template<class = void>
    A(int = 0) {} // A 拥有用户提供的默认构造函数，它没有被选择
    int x;
};
 
constexpr int test(A a) {
    return a.x; // 如果 a 的值不确定则行为未定义
}
 
constexpr int zero = test(A());
// 谬构：按照标准不会零初始化形参，这导致未定义行为，并在要求常量求值的语境中使程序谬构。
// 然而所有已知编译器都接受这种代码。
 
void f() {
    A a = A(); // 按照标准不被零初始化
               // 但实现还是会生成零初始化的代码
}

示例

运行此代码
#include <string>
#include <vector>
#include <iostream>
 
struct T1
{
    int mem1;
    std::string mem2;
}; // 隐式默认构造函数
 
struct T2
{
    int mem1;
    std::string mem2;
    T2(const T2&) { } // 用户提供的复制构造函数
};                    // 无默认构造函数
 
struct T3
{
    int mem1;
    std::string mem2;
    T3() { } // 用户提供的默认构造函数
};
 
std::string s{}; // 类 => 默认初始化，值为 ""
 
int main()
{
    int n{};                // 标量 => 零初始化，值为 0
    double f = double();    // 标量 => 零初始化，值为 0.0
    int* a = new int[10](); // 数组 => 每个元素的值初始化
                            //          每个元素的值为 0
    T1 t1{};                // 有隐式默认构造函数的类 =>
                            //     t1.mem1 被零初始化，值为 0
                            //     t1.mem2 被默认初始化，值为 ""
//  T2 t2{};                // 错误：类无默认构造函数
    T3 t3{};                // 有用户提供默认构造函数的类 =>
                            //     t3.mem1 被默认初始化为不确定值
                            //     t3.mem2 被默认初始化，值为 ""
    std::vector<int> v(3);  // 值初始化每个元素
                            // 每个元素的值为 0
    std::cout << s.size() << ' ' << n << ' ' << f << ' ' << a[9] << ' ' << v[2] << '\n';
    std::cout << t1.mem1 << ' ' << t3.mem1 << '\n';
    delete[] a;
}

可能的输出： 

0 0 0 0 0
0 4199376

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

DR 应用于 出版时的行为 正确行为
CWG 1301 C++11 默认化的默认构造函数跳过构造前的零初始化 进行零初始化

参阅

来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/language/value_initialization&oldid=71365”