从初始化列表初始化 std::tuple

Question

我想知道元组是否可以通过初始化列表初始化（更准确地说，通过初始化列表的初始化列表）？考虑元组定义：

typedef std::tuple< std::array<short, 3>,
                    std::array<float, 2>,
                    std::array<unsigned char, 4>,
                    std::array<unsigned char, 4> > vertex;

有没有办法做到以下几点：

static vertex const nullvertex = { {{0, 0, 0}},
                                   {{0.0, 0.0}},
                                   {{0, 0, 0, 0}},
                                   {{0, 0, 0, 0}} };

我只想实现与使用 struct 而不是 tuple 相同的功能（因此只有数组由 initializer_list 初始化）：

static struct vertex {
    std::array<short, 3> m_vertex_coords;
    std::array<float, 2> m_texture_coords;
    std::array<unsigned char, 4> m_color_1;
    std::array<unsigned char, 4> m_color_2;
} const nullvertex = {
    {{0, 0, 0}},
    {{0.0, 0.0}},
    {{0, 0, 0, 0}},
    {{0, 0, 0, 0}}
};

我没有理由必须使用元组，只是想知道。我在问，因为我无法通过我尝试进行此类元组初始化而生成的 g++ 模板错误。

@Motti：所以我错过了统一初始化的正确语法 -

static vertex const nullvertex = vertex{ {{0, 0, 0}},
                                         {{0.0, 0.0}},
                                         {{0, 0, 0, 0}},
                                         {{0, 0, 0, 0}} };

和

static vertex const nullvertex{ {{0, 0, 0}},
                                {{0.0, 0.0}},
                                {{0, 0, 0, 0}},
                                {{0, 0, 0, 0}} };

但似乎所有的麻烦都在于数组，它没有用于 initializer_list 的构造函数，并且用适当的构造函数包装数组似乎不是一件容易的事。

Answer 1

初始化列表与元组无关。

我认为您混淆了 C++0x 中花括号的两种不同用法。

1. initializer_list<T> 是同构集合（所有成员必须属于同一类型，因此与 std::tuple 无关）
2. Uniform initialization 是使用大括号来构造各种对象的地方；具有构造函数的数组、POD 和类。这也有解决the most vexing parse)的好处

这是一个简化版：

std::tuple<int, char> t = { 1, '1' }; 
// error: converting to 'std::tuple<int, char>' from initializer list would use
// explicit constructor 'std::tuple<_T1, _T2>::tuple(_U1&&, _U2&&) 
// [with _U1 = int, _U2 = char, _T1 = int, _T2 = char]'

std::tuple<int, char> t { 1, '1' }; // note no assignment
// OK, but not an initializer list, uniform initialization

错误消息是你试图隐式调用构造函数，但它是显式构造函数，所以你不能。

基本上你想要做的是这样的：

struct A { 
    explicit A(int) {}
};

A a0 = 3;
// Error: conversion from 'int' to non-scalar type 'A' requested

A a1 = {3}; 
// Error: converting to 'const A' from initializer list would use 
// explicit constructor 'A::A(int)'

A a2(3); // OK C++98 style
A a3{3}; // OK C++0x Uniform initialization