C++11中跳转initializer_list实现分析

简介

在 C++11 标准之前，C++ 中只有 C 风格的可变参数传递，而在 C++11 中加入了新的 initializer_list 类型，从而实现了更加方便和安全的可变参数列表传递。
initializer_list 可以看作是一个轻量级的容器，只能存放相同类型的变量，支持动态数组大小的初始化，并且可以像数组或标准容器一样进行迭代访问。

initializer_list 的定义和用法

定义

initializer_list 类型定义在头文件 <initializer_list> 中，其定义如下：

namespace std {
    template<class T>
    class initializer_list {
    public:
        using value_type      = T;
        using reference       = const T&;
        using const_reference = const T&;
        using size_type       = size_t;

        using iterator        = const T*;
        using const_iterator  = const T*;

        constexpr initializer_list() noexcept;
        constexpr size_t size() const noexcept;
        constexpr const T* begin() const noexcept;
        constexpr const T* end() const noexcept;
    };
    . . . . .
}

用法

使用 initializer_list 的一般方法是利用其构造函数进行初始化，然后像使用容器一样访问其中的元素：

#include <iostream>
#include <initializer_list>

int main()
{
    std::initializer_list<int> list = { 1, 2, 3 };
    for (auto i : list) {
        std::cout << i << std::endl;
    }
    return 0;
}

输出结果：

1
2
3

跳转 initializer_list 的实现

C++11 新增了跳转语句 return expr;，其中 expr 是一个 initializer_list，用于在函数内跳转到该语句处并返回一组指定的值。
使用跳转语句可以实现 initializer_list 的传递，具体实现方法如下：

#include <iostream>
#include <initializer_list>

// 接收可变参数列表的函数
void function(std::initializer_list<int> list)
{
    for (auto i : list) { // 遍历数组
        std::cout << i << std::endl; // 打印
    }
}

// 返回可变参数列表的函数
std::initializer_list<int> get_list()
{
    std::initializer_list<int> list = { 1, 2, 3 };
    return list; // 返回数组
}

int main()
{
    // 调用函数传递可变参数列表
    function({1, 2, 3});

    // 调用函数返回可变参数列表
    std::initializer_list<int> list = get_list();
    for (auto i : list) { // 遍历数组
        std::cout << i << std::endl; // 打印
    }

    return 0;
}

输出结果：

1
2
3
1
2
3

以上示例说明了在函数参数中使用 initializer_list 和函数返回值中使用 initializer_list 的使用方式。其中 function 函数使用了可变参数列表作为函数参数，在函数内部遍历多个参数，而 get_list 函数返回了一个 initializer_list，其内部有三个元素。函数调用时，在花括号中传入实际参数，然后在函数体中实现遍历或其他操作。

示例

示例1：简单的可变参数宏

在实际编码过程中，我们往往会使用可变参数宏，它可以接受可变的参数并进行处理。下面是一个简单的示例：

#include <iostream>

#define DEBUG_PRINT(...) std::cout << #__VA_ARGS__ << " = " << (__VA_ARGS__) << std::endl;

int main()
{
    int a = 1, b = 2, c = 3;
    DEBUG_PRINT(a, b, c); // 使用可变参数宏打印变量值
    return 0;
}

输出结果：

a, b, c = 1 2 3

示例 2：结合 stl 算法的使用

我们也可以结合 STL 算法对可变参数列表进行处理。例如在下面的代码中，我们定义了一个 container 容器，然后使用 find 算法遍历该容器，查找元素是否在容器内。其中可以注意到，我们在算法的第一个参数中使用了可变参数列表。

#include <algorithm>
#include <iostream>
#include <vector>

template <typename ... Args>
bool find_in_container(const std::vector<int>& container, Args&&... args)
{
  return std::find(container.begin(), container.end(), std::forward<Args>(args)) != container.end();
}

int main()
{
    std::vector<int> container = { 1, 2, 3, 4, 5 };
    std::cout << std::boolalpha;

    // 查找容器中的元素
    std::cout << find_in_container(container, 3, 4, 5) << std::endl; // 输出 true
    std::cout << find_in_container(container, 6, 7, 8) << std::endl; // 输出 false

    return 0;
}

输出结果：

true
false