【C++ 学习 ㉘】- 详解 C++11 的列表初始化

melonyzzZ2023-10-18 17:15

目录

[一、C++11 简介](#一、C++11 简介)

二、列表初始化

[2.1 - 统一初始化](#2.1 - 统一初始化)

[2.2 - 列表初始化的使用细节](#2.2 - 列表初始化的使用细节)

[2.2.1 - 聚合类型的定义](#2.2.1 - 聚合类型的定义)

[2.2.2 - 注意事项](#2.2.2 - 注意事项)

[2.3 - initializer_list](#2.3 - initializer_list)

[2.3.1 - 基本使用](#2.3.1 - 基本使用)

[2.3.2 - 源码剖析](#2.3.2 - 源码剖析)

一、C++11 简介

  1. 1998 年，C++ 标准委员会发布了第一版 C++ 标准，即 C++98 标准，并计划以后每 5 年视实际需要更新一次标准。

    所谓标准，即明确 C++ 代码的编写规范，所有的 C++ 程序员都应遵守此标准。

  2. 2003 年，C++ 标准委员会发布了第二版 C++ 标准，即 C++03 标准，但由于 C++03 仅修复了一些 C++98 中存在的漏洞，并未修改核心语法，因此人们习惯将这两个标准合称为 C++98/03 标准。

  3. 2011 年，C++ 标准委员会发布了第三版 C++ 标准，即 C++11 标准，相比 C++03，C++11 带来了数量可观的变化，其中包含了约 140 个新特性，以及对 C++03 中约 600 个缺陷的修正，这使得 C++11 更像从 C++98/03 中孕育出来的一种新语言。。

    C++ 标准委员会一开始是计划在 2007 年发布第三版 C++ 标准，即 C++07 标准，但在 2006 年时，标准委员会认为到 2007 年，甚至到 2008 年，都可能无法发布第三版 C++ 标准，所以干脆将第三版 C++ 标准命名为 C++0x，即计划在二十一世纪的第一个 10 年的某个时间发布，但最终直到 2011 年才发布第三版 C++ 标准。

二、列表初始化

在 C++98/03 中，对象的初始化方式有很多种，这些不同的初始化方式都有各自的适用范围和作用，没有一种方式可以通用于所有情况。为了统一初始化方式，并且让初始化行为具有确定的效果，C++11 提出了列表初始化的概念。

2.1 - 统一初始化

在 C++98/03 中，对于普通数组和可以直接进行内存拷贝（memcpy）的对象，可以使用列表初始化来初始化数据。

cpp 复制代码 
int arr[5] = { 0, 1, 2, 3, 4 };
​
struct Point
{
    int _x;
    int _y;
} p = { 0, 0 };

在 C++11 中，初始化列表的适用性被大大地增加了，它现在可以适用于任何类型对象的初始化。

注意：在 C++11 中，使用列表初始化时，可以添加等号（=），也可以不添加等号。

cpp 复制代码 
class A
{
public:
    A(int i = 0) : _i(i) { }
private:
    A(const A& a) : _i(a._i) { }
private:
    int _i;
};
​
int main()
{
    A a1(10);
    A a2 = 10;
    A a3 = { 10 };
    A a4{ 10 };
    return 0;
}

  1. a3、a4 使用了 C++11 的列表初始化来初始化对象，效果如同 a1 的直接初始化。

  2. 至于 a2，10 会通过隐式类型转换调用构造函数 A(int i = 0) 构造出一个匿名对象，然后通过这个匿名对象调用拷贝构造函数 A(const A& a) 构造出 a2，但由于拷贝构造函数是私有的（private），所以编译器会报错。

    注意：Linux 中的 g++ 编译器会报错，VS 中的编译器则不会报错。

使用 new 操作符创建新对象时也可以使用列表初始化来初始化对象。

cpp 复制代码 
int* p = new int{ 0 };
int* arr = new int[5]{ 0, 1, 2, 3, 4 };

除了上面所述的内容，列表初始化还可以直接用在函数传参和返回值上。

cpp 复制代码 
#include <iostream>
#include <string>
using namespace std;
​
class Person
{
public:
    Person(int id, string name) : _id(id), _name(name)
    {
        cout << _id << ":" << _name << endl;
    }
private:
    int _id;
    string _name;
};
​
void func1(Person p) { }
​
Person func2() { return { 2, "李四" }; }
​
int main()
{
    func1({ 1, "张三" });  // 1:张三
    Person p = func2();  // 2:李四
    return 0;
}

2.2 - 列表初始化的使用细节

在 C++11 中，列表初始化的使用范围被大大地增加了，但一些模糊的概念也随之而来。

cpp 复制代码 
#include <iostream>
using namespace std;
​
struct T1
{
    int _x;
    int _y;
} t1{ 520, 520 };
​
struct T2
{
    int _x;
    int _y;
​
    T2(int, int) : _x(1314), _y(1314) { }
} t2{ 520, 520 };
​
int main()
{
    cout << t1._x << ", " << t1._y << endl;  // 520, 520
    cout << t2._x << ", " << t2._y << endl;  // 1314, 1314
    return 0;
}

在上面的程序中，t1 和 t2 都使用相同的列表初始化来初始化对象，但输出的结果却不同。因为对于聚合类型的对象 t1，它可以直接使用列表初始化来初始化对象；对于非聚合类型的对象 t2，它是基于构造函数使用列表初始化来初始化对象。

2.2.1 - 聚合类型的定义

  1. 普通数组可以看作是一个聚合类型。

  2. 满足以下条件的类（class、struct、union）可以看作是一个聚合类型：

    • 无基类、无虚函数以及无用户自定义的构造函数。

    • 无 private 或 protected 的普通数据成员（即非静态数据成员）。

      cpp 复制代码 
      struct T1
{
    int _x;
    int _y;
private:  // 或者 protected
    int _z;
} t1{ 1, 2, 3 };  // error（类中有私有成员，无法使用列表初始化进行初始化）
​
struct T2
{
    int _x;
    int _y;
protected:  // 或者 protected
    static int _z; 
} t2{ 1, 2 };  // ok
​
int T2::_z = 3;  // 注意：静态数据成员 _z 不能使用列表初始化进行初始化

    • 类中不能有 {} 和 = 直接初始化的非静态数据成员（即就地初始化）。

      cpp 复制代码 
      struct T3
{
    int _x = 1;
    int _y{ 2 };
} t3{ 0, 0 };  // error（C++11）

      注意：从 C++14 开始，也可以使用列表初始化来初始化类中使用 {} 和 = 初始化过的非静态数据成员。

2.2.2 - 注意事项

聚合类型的定义并非递归的，即当一个类的非静态数据成员是非聚合类型时，这个类也可能是聚合类型。

cpp 复制代码 
struct T1
{
    int _x;
    int _y;
private:
    int _z;
public:
    T1() : _x(1), _y(2), _z(3) { }
};
​
struct T2
{
    T1 _t1;
    double _d;
};
​
int main()
{
    T2 t2{ {}, 3.14 };
    return 0;
}

可以看到，T1 是非聚合类型，因为它有一个 private 的非静态数据成员，但 T2 依然是一个聚合类型，可以直接使用列表初始化来初始化对象 t2。

注意：使用列表初始化来初始化 t2 的非聚合类型成员 _t1 时，可以直接写一对空的大括号 {}，这相当于调用 _t1 的默认构造函数。

2.3 - initializer_list

2.3.1 - 基本使用

当编译器看到 { t1, t2, ..., tn } 时，便会生成一个 initializer_list<T> 类型的对象（其中 T 为元素的类型），它关联到一个 array<T, n>。

cpp 复制代码 
#include <iostream>
using namespace std;
​
int main()
{
    auto il = { 10, 20, 30 };
    cout << typeid(il).name() << endl;  // class std::initializer_list<int>
    return 0;
}

对于聚合类型，编译器会将 array<T, n> 内的元素逐一分解并赋值给被初始化的对象，这相当于为该对象每个字段分别赋值。

对于非聚合类型，如果该类存在一个接收 initializer_list<T> 类型的构造函数，则初始化时会将 initializer_list<T> 对象作为一个整体传给构造函数；如果该类不存在这样的构造函数，则 array<T, n> 内的元素会被编译器分解并传给相应的能接收这些参数的构造函数（比如列表中有 2 个元素，就传给带 2 个参数的构造函数，有 3 个元素，就传给带 3 个参数的构造函数，依次类推）。

cpp 复制代码 
#include <iostream>
#include <vector>
using namespace std;
​
class Test
{
public:
    Test(int) { cout << "Test(int)" << endl; }
​
    Test(int, int) { cout << "Test(int, int)" << endl; }
};
​
int main()
{
    // vector (initializer_list<value_type> il, 
    //      const allocator_type& alloc = allocator_type());
    vector<int> v{ 0, 1, 2, 3, 4 };
    for (const auto& e : v)
    {
        cout << e << " ";
    }
    // 0 1 2 3 4
    cout << endl;
    
    Test t1{ 1 };  // Test(int)
    Test t2{ 1, 2 };  // Test(int, int)
    return 0;
}

2.3.2 - 源码剖析

cpp 复制代码 
#include <iostream>
​
template <class T>
class initializer_list
{
public:
    typedef T        value_type;
    typedef const T& reference;  // 说明对象永远为 const，不能被外部修改！
    typedef const T& const_reference;
    typedef size_t   size_type;
    typedef const T* iterator;  // 永远为 const 类型
    typedef const T* const_iterator;
    
private:
    iterator  _M_array; // 用于存放用列表初始化中的元素
    size_type _M_len;   // 元素的个数
​
    // 注意：编译器可以调用 private 的构造函数！！！
    // 构造函数在调用之前，编译会先在外部准备好一个 array，
    // 同时把 array 的地址传入模板，并保存在 _M_array 中
    constexpr initializer_list(const_iterator __a, size_type __l)
        :_M_array(__a), _M_len(__l) {};  // 注意该构造函数被放到 private 中！
    
public:
    // 无参的构造函数
    constexpr initializer_list() : _M_array(0), _M_len(0) {} 
​
    // 用于获取元素的个数
    constexpr size_type size() const noexcept { return _M_len; }
​
    // 获取第一个元素的位置
    constexpr const_iterator begin() const noexcept { return _M_array; }
​
    // 获取最后一个元素的下一个位置
    constexpr const_iterator end() const noexcept
    {
        return begin() + _M_len;
    }
};

让模拟实现的 vector 也支持列表初始化：

cpp 复制代码 
namespace yzz
{
    template<class T>
    class vector
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
​
        vector(std::initializer_list<T> il) :
            _start(new T[il.size()]),
            _finish(_start + il.size()),
            _end_of_storage(_finish)
        {
            iterator v_it = _start;
            typename std::initializer_list<T>::iterator il_it = il.begin();
            while (il_it != il.end())
            {
                *v_it++ = *il_it++;
            }
        }
        // ... ...
    private:
        iterator _start;
        iterator _finish;
        iterator _end_of_storage;
    };
}
相关推荐
训山6 分钟前
4000字浅谈Java网络编程
java·开发语言·网络
API快乐传递者7 分钟前
除了网页标题，还能用爬虫抓取哪些信息？
开发语言·爬虫·python
VertexGeek12 分钟前
Rust学习（四）：作用域、所有权和生命周期：
java·学习·rust
hutaotaotao1 小时前
c语言用户不同命令调用不同函数实现
c语言·开发语言
抱走江江1 小时前
SpringCloud框架学习（第二部分：Consul、LoadBalancer和openFeign）
学习·spring·spring cloud
huangjiazhi_1 小时前
QTcpSocket 服务端和客户端
开发语言·qt
ac-er88881 小时前
ThinkPHP中的MVC分层是什么
开发语言·php·mvc
槿花Hibiscus1 小时前
C++基础：Pimpl设计模式的实现
c++·设计模式
shinelord明2 小时前
【再谈设计模式】建造者模式~对象构建的指挥家
开发语言·数据结构·设计模式
黑不拉几的小白兔2 小时前
PTA部分题目C++重练
开发语言·c++·算法
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10智能车联网安全发展形势、挑战