跳到主要内容

C++ 11初始化列表

介绍​

C++11引入的初始化列表（Initializer List）是一个非常实用的特性，它为我们提供了一种统一、直观的初始化对象的方式。在C++11之前，不同类型的对象可能需要不同的初始化语法，这导致代码可能不够一致和直观。通过初始化列表，我们可以用一种更简洁、更统一的方式来初始化各种对象，包括内置类型、STL容器、自定义类等。

基础语法​

初始化列表的基本语法是使用花括号 {} 包围一组值。这种方式称为花括号初始化（Brace Initialization）或统一初始化（Uniform Initialization）。

cpp
// 基本类型的初始化
int a{10};           // 直接初始化
int b = {20};        // 拷贝初始化
int c{};             // 默认初始化为0

// 数组初始化
int array[]{1, 2, 3, 4, 5};

// 动态分配的数组
int* dynamicArray = new int[3]{1, 2, 3};

std::initializer_list<T>​

初始化列表的核心是 std::initializer_list<T> 模板类，它定义在 <initializer_list> 头文件中。当我们使用花括号初始化时，编译器会自动创建一个 std::initializer_list<T> 对象。

cpp
#include <initializer_list>
#include <iostream>

void printNumbers(std::initializer_list<int> numbers) {
    for (auto num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
}

int main() {
    // 调用使用初始化列表
    printNumbers({1, 2, 3, 4, 5});
    
    // 输出: 1 2 3 4 5
    
    return 0;
}

STL容器与初始化列表​

C++11中，所有的STL容器都支持初始化列表，这使得容器的初始化变得更加简洁和直观。

cpp
#include <vector>
#include <map>
#include <string>
#include <iostream>

int main() {
    // 初始化vector
    std::vector<int> vec{1, 2, 3, 4, 5};
    
    // 初始化list
    std::list<std::string> names{"Alice", "Bob", "Charlie"};
    
    // 初始化map
    std::map<std::string, int> ages{
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 35}
    };
    
    // 展示结果
    std::cout << "Vector内容: ";
    for (auto val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
    
    // 输出: Vector内容: 1 2 3 4 5
    
    return 0;
}

自定义类与初始化列表​

自定义类可以通过定义构造函数来接受初始化列表，让我们能够使用花括号语法初始化自定义对象。

cpp
#include <initializer_list>
#include <vector>
#include <iostream>

class MyContainer {
private:
    std::vector<int> data;
    
public:
    // 接受初始化列表的构造函数
    MyContainer(std::initializer_list<int> list) : data(list) {
        std::cout << "使用初始化列表构造MyContainer" << std::endl;
    }
    
    void print() const {
        for (auto val : data) {
            std::cout << val << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    MyContainer container{10, 20, 30, 40, 50};
    std::cout << "容器内容: ";
    container.print();
    
    // 输出:
    // 使用初始化列表构造MyContainer
    // 容器内容: 10 20 30 40 50
    
    return 0;
}
提示

当你的类需要接受不定数量的初始值时，使用初始化列表构造函数是一个很好的选择。

初始化列表的类型转换规则​

使用初始化列表时，C++会进行严格的类型检查，这有助于防止数据丢失的隐式转换。

cpp
int x{10.5};    // 错误: 可能损失数据的转换
int y = {10.5}; // 错误: 同样会报错

char c{1000};   // 错误: 1000超出了char的范围

std::vector<int> v{1, 2.3}; // 错误: 2.3不能无损转换为int
警告

花括号初始化比传统的括号初始化或赋值初始化更严格，它禁止可能导致数据丢失的隐式类型转换。

初始化列表与聚合初始化​

C++中的聚合类型（例如数组和某些类）可以通过聚合初始化来初始化：

cpp
// 聚合结构的初始化
struct Point {
    int x;
    int y;
};

Point p1{10, 20};   // 聚合初始化
Point p2 = {30, 40}; // 同样是聚合初始化

嵌套初始化列表​

初始化列表可以嵌套使用，这在初始化复杂结构时特别有用：

cpp
// 二维数组初始化
int matrix[][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 复杂结构初始化
struct Person {
    std::string name;
    int age;
    std::vector<std::string> hobbies;
};

Person alice{"Alice", 25, {"reading", "coding", "hiking"}};

实际应用案例​

案例1: 图形应用中的点集合​

假设我们正在开发一个简单的图形应用，需要处理多个点的集合:

cpp
#include <vector>
#include <iostream>

struct Point {
    double x;
    double y;
    
    void print() const {
        std::cout << "(" << x << ", " << y << ")";
    }
};

class Polygon {
private:
    std::vector<Point> vertices;
    
public:
    Polygon(std::initializer_list<Point> points) : vertices(points) {}
    
    void draw() const {
        std::cout << "多边形的顶点: " << std::endl;
        for (const auto& point : vertices) {
            point.print();
            std::cout << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    // 使用初始化列表轻松创建多边形
    Polygon triangle{
        {0.0, 0.0},
        {1.0, 0.0},
        {0.5, 0.87}
    };
    
    triangle.draw();
    
    // 输出:
    // 多边形的顶点: 
    // (0, 0) (1, 0) (0.5, 0.87) 
    
    return 0;
}

案例2: 配置设置​

初始化列表可以用于简化配置设置的初始化:

cpp
#include <map>
#include <string>
#include <iostream>

class ApplicationConfig {
private:
    std::map<std::string, std::string> settings;
    
public:
    ApplicationConfig(std::initializer_list<std::pair<const std::string, std::string>> configs)
        : settings(configs) {}
    
    std::string get(const std::string& key, const std::string& defaultValue = "") const {
        auto it = settings.find(key);
        if (it != settings.end()) {
            return it->second;
        }
        return defaultValue;
    }
};

int main() {
    ApplicationConfig config{
        {"db_host", "localhost"},
        {"db_port", "3306"},
        {"db_user", "admin"},
        {"db_password", "secure123"},
        {"app_name", "MyAwesomeApp"}
    };
    
    std::cout << "应用名称: " << config.get("app_name") << std::endl;
    std::cout << "数据库连接: " << config.get("db_user") << "@" 
              << config.get("db_host") << ":" << config.get("db_port") << std::endl;
    
    // 输出:
    // 应用名称: MyAwesomeApp
    // 数据库连接: admin@localhost:3306
    
    return 0;
}

总结​

C++11的初始化列表是一个强大的特性，它为C++程序员提供了以下好处:

  1. 统一的初始化语法 - 无论是内置类型、STL容器还是自定义类型，都可以使用一致的语法进行初始化
  2. 防止窄化转换 - 初始化列表的严格类型检查有助于捕获可能导致数据丢失的类型转换
  3. 代码简洁性 - 尤其对于容器类型，初始化列表使得代码更加简洁和可读
  4. 灵活性 - 通过std::initializer_list，自定义类型可以以自然的方式接受不定数量的初始值
注意

虽然初始化列表很强大，但在涉及到构造函数重载解析时可能会有一些微妙的行为，特别是当一个类同时有接受initializer_list的构造函数和其他构造函数时。通常情况下，接受初始化列表的构造函数会被优先选择。

练习​

  1. 创建一个Matrix类，使其能够通过初始化列表接受一个二维数组初始化。
  2. 实现一个Settings类，它可以通过初始化列表接受键值对配置项，并提供获取和设置配置的方法。
  3. 修改标准库中某个容器的用法，使用初始化列表代替传统的插入方法。

延伸阅读​