（注意：这个问题是不必指定元素的数量，仍然允许直接初始化嵌套类型。）
This question讨论了int arr[20];等C数组的用途。在his answer上，@ James Kanze展示了C阵列的最后一个据点，它具有独特的初始化特性：
int arr[] = { 1, 3, 3, 7, 0, 4, 2, 0, 3, 1, 4, 1, 5, 9 };
我们没有指定元素的数量，万岁！现在使用来自std::begin（or your own variants）的C ++ 11函数std::end和<iterator>进行迭代，您甚至不需要考虑它的大小。
现在，是否有任何（可能是TMP）方法与std::array实现相同的目标？使用宏可以使它看起来更好。 ：）
??? std_array = { "here", "be", "elements" };
编辑：从各种答案编译的中级版本如下所示：
#include <array>
#include <utility>
template<class T, class... Tail, class Elem = typename std::decay<T>::type>
std::array<Elem,1+sizeof...(Tail)> make_array(T&& head, Tail&&... values)
{
return { std::forward<T>(head), std::forward<Tail>(values)... };
}
// in code
auto std_array = make_array(1,2,3,4,5);
并使用各种很酷的C ++ 11东西：
sizeof... std::array，当然auto）可以找到一个例子here。
然而，正如@Johannes在@Xaade的回答评论中指出的那样，你不能用这样的函数初始化嵌套类型。例如：
struct A{ int a; int b; };
// C syntax
A arr[] = { {1,2}, {3,4} };
// using std::array
??? std_array = { {1,2}, {3,4} };
此外，初始化程序的数量仅限于实现支持的函数和模板参数的数量。
答案 0 :(得分：59)
我能想到的最好的是：
template<class T, class... Tail>
auto make_array(T head, Tail... tail) -> std::array<T, 1 + sizeof...(Tail)>
{
std::array<T, 1 + sizeof...(Tail)> a = { head, tail ... };
return a;
}
auto a = make_array(1, 2, 3);
但是，这需要编译器执行NRVO，然后也跳过返回值的副本（这也是合法的但不是必需的）。在实践中，我希望任何C ++编译器能够优化它，使其与直接初始化一样快。
答案 1 :(得分：37)
我希望有一个简单的make_array。
template<typename ret, typename... T> std::array<ret, sizeof...(T)> make_array(T&&... refs) {
// return std::array<ret, sizeof...(T)>{ { std::forward<T>(refs)... } };
return { std::forward<T>(refs)... };
}
答案 2 :(得分：20)
结合以前帖子中的一些想法，这里的解决方案甚至适用于嵌套结构（在GCC4.6中测试）：
template <typename T, typename ...Args>
std::array<T, sizeof...(Args) + 1> make_array(T && t, Args &&... args)
{
static_assert(all_same<T, Args...>::value, "make_array() requires all arguments to be of the same type."); // edited in
return std::array<T, sizeof...(Args) + 1>{ std::forward<T>(t), std::forward<Args>(args)...};
}
奇怪的是，无法使返回值成为rvalue引用，这对嵌套构造不起作用。无论如何，这是一个测试：
auto q = make_array(make_array(make_array(std::string("Cat1"), std::string("Dog1")), make_array(std::string("Mouse1"), std::string("Rat1"))),
make_array(make_array(std::string("Cat2"), std::string("Dog2")), make_array(std::string("Mouse2"), std::string("Rat2"))),
make_array(make_array(std::string("Cat3"), std::string("Dog3")), make_array(std::string("Mouse3"), std::string("Rat3"))),
make_array(make_array(std::string("Cat4"), std::string("Dog4")), make_array(std::string("Mouse4"), std::string("Rat4")))
);
std::cout << q << std::endl;
// produces: [[[Cat1, Dog1], [Mouse1, Rat1]], [[Cat2, Dog2], [Mouse2, Rat2]], [[Cat3, Dog3], [Mouse3, Rat3]], [[Cat4, Dog4], [Mouse4, Rat4]]]
（对于最后一个输出我正在使用我的pretty-printer。）
实际上，让我们改善这种结构的类型安全性。我们绝对需要所有类型都一样。一种方法是添加一个静态断言，我在上面编辑过。另一种方法是仅在类型相同时启用make_array，如下所示：
template <typename T, typename ...Args>
typename std::enable_if<all_same<T, Args...>::value, std::array<T, sizeof...(Args) + 1>>::type
make_array(T && t, Args &&... args)
{
return std::array<T, sizeof...(Args) + 1> { std::forward<T>(t), std::forward<Args>(args)...};
}
无论哪种方式，您都需要可变all_same<Args...>类型特征。在这里，从std::is_same<S, T>推广（请注意，衰减对于允许混合T，T&，T const &等非常重要。）
template <typename ...Args> struct all_same { static const bool value = false; };
template <typename S, typename T, typename ...Args> struct all_same<S, T, Args...>
{
static const bool value = std::is_same<typename std::decay<S>::type, typename std::decay<T>::type>::value && all_same<T, Args...>::value;
};
template <typename S, typename T> struct all_same<S, T>
{
static const bool value = std::is_same<typename std::decay<S>::type, typename std::decay<T>::type>::value;
};
template <typename T> struct all_same<T> { static const bool value = true; };
请注意make_array()通过临时副本返回，编译器（具有足够的优化标志！）被允许视为右值或以其他方式优化，std::array是聚合类型，所以编译器可以自由选择最好的构造方法。
最后，请注意，当make_array设置初始化程序时，您无法避免复制/移动构造。因此std::array<Foo,2> x{Foo(1), Foo(2)};没有复制/移动，但auto x = make_array(Foo(1), Foo(2));有两个副本/移动，因为参数被转发到make_array。我不认为你可以改进，因为如果预处理器有一个sizeof...函数，你就不能将一个可变参数化的初始化列表以词法方式传递给辅助函数和演绎类型和大小。对于可变参数，也许可以这样做，但不是在核心语言中。
答案 3 :(得分：10)
使用尾随返回语法make_array可以进一步简化
#include <array>
#include <type_traits>
#include <utility>
template <typename... T>
auto make_array(T&&... t)
-> std::array<std::common_type_t<T...>, sizeof...(t)>
{
return {std::forward<T>(t)...};
}
int main()
{
auto arr = make_array(1, 2, 3, 4, 5);
return 0;
}
不幸的是，对于聚合类，它需要显式类型规范
/*
struct Foo
{
int a, b;
}; */
auto arr = make_array(Foo{1, 2}, Foo{3, 4}, Foo{5, 6});
make_array实现
感谢template argument deduction for class templates提案，我们可以使用扣除指南来摆脱make_array帮助
#include <array>
namespace std
{
template <typename... T> array(T... t)
-> array<std::common_type_t<T...>, sizeof...(t)>;
}
int main()
{
std::array a{1, 2, 3, 4};
return 0;
}
在x86-64 gcc 7.0下编译-std=c++1z标志
答案 4 :(得分：6)
C ++ 11将支持this manner of initialization（大多数？）std容器。
答案 5 :(得分：6)
我知道自从提出这个问题以来已经有一段时间了，但我觉得现有的答案仍有一些缺点，所以我想提出我稍微修改过的版本。以下是我认为缺少一些现有答案的要点。
有些答案提到我们需要依靠RVO来返回构造的array。那不是真的;我们可以利用copy-list-initialization来保证永远不会创造临时。所以而不是：
return std::array<Type, …>{values};
我们应该这样做：
return {{values}};
make_array设为constexpr函数这允许我们创建编译时常量数组。
首先，如果不是，编译器将发出警告或错误，因为列表初始化不允许缩小。其次，即使我们真的决定做我们自己的static_assert事情（也许是为了提供更好的错误信息），我们仍然应该比较' decayed 类型而不是原始类型的参数。例如，
volatile int a = 0;
const int& b = 1;
int&& c = 2;
auto arr = make_array<int>(a, b, c); // Will this work?
如果我们只是static_assert a，b和c具有相同的类型，那么此检查将失败，但这可能不是什么我们期待。相反，我们应该比较他们的std::decay_t<T>类型（都是int s）。
这与第3点类似。使用相同的代码段，但这次没有明确指定值类型：
volatile int a = 0;
const int& b = 1;
int&& c = 2;
auto arr = make_array(a, b, c); // Will this work?
我们可能想要制作array<int, 3>，但现有答案中的实现可能都无法做到。我们可以做的是，而不是返回std::array<T, …>，而是返回std::array<std::decay_t<T>, …>。
这种方法有一个缺点：我们不能再返回array cv限定值类型。但大多数情况下，我们会使用array<const int, …>而不是const array<int, …>之类的东西。有一个权衡，但我认为是合理的。 C ++ 17 std::make_optional也采用了这种方法：
template< class T >
constexpr std::optional<std::decay_t<T>> make_optional( T&& value );
考虑到以上几点，C ++ 14中make_array的完整工作实现如下：
#include <array>
#include <type_traits>
#include <utility>
template<typename T, typename... Ts>
constexpr std::array<std::decay_t<T>, 1 + sizeof... (Ts)>
make_array(T&& t, Ts&&... ts)
noexcept(noexcept(std::is_nothrow_constructible<
std::array<std::decay_t<T>, 1 + sizeof... (Ts)>, T&&, Ts&&...
>::value))
{
return {{std::forward<T>(t), std::forward<Ts>(ts)...}};
}
template<typename T>
constexpr std::array<std::decay<T>_t, 0> make_array() noexcept
{
return {};
}
用法：
constexpr auto arr = make_array(make_array(1, 2),
make_array(3, 4));
static_assert(arr[1][1] == 4, "!");
答案 6 :(得分：5)
（@dyp解决方案）
注意：需要 C ++ 14 （std::index_sequence）。虽然可以在C ++ 11中实现std::index_sequence。
#include <iostream>
// ---
#include <array>
#include <utility>
template <typename T>
using c_array = T[];
template<typename T, size_t N, size_t... Indices>
constexpr auto make_array(T (&&src)[N], std::index_sequence<Indices...>) {
return std::array<T, N>{{ std::move(src[Indices])... }};
}
template<typename T, size_t N>
constexpr auto make_array(T (&&src)[N]) {
return make_array(std::move(src), std::make_index_sequence<N>{});
}
// ---
struct Point { int x, y; };
std::ostream& operator<< (std::ostream& os, const Point& p) {
return os << "(" << p.x << "," << p.y << ")";
}
int main() {
auto xs = make_array(c_array<Point>{{1,2}, {3,4}, {5,6}, {7,8}});
for (auto&& x : xs) {
std::cout << x << std::endl;
}
return 0;
}
答案 7 :(得分：1)
С++ 17紧凑的实现。
template <typename... T>
constexpr auto array_of(T&&... t) {
return std::array{ static_cast<std::common_type_t<T...>>(t)... };
}
答案 8 :(得分：0)
如果std :: array不是约束，并且你有Boost，那么看一下list_of()。这与您想要的C类型数组初始化完全不同。但是关闭。
答案 9 :(得分：0)
创建数组制作者类型。
重载operator,以生成一个表达式模板，将每个元素链接到之前的引用。
添加finish免费函数，该函数接受数组生成器并直接从引用链生成数组。
语法应如下所示：
auto arr = finish( make_array<T>->* 1,2,3,4,5 );
它不允许基于{}的构造，因为只有operator=。如果您愿意使用=，我们可以让它发挥作用：
auto arr = finish( make_array<T>= {1}={2}={3}={4}={5} );
或
auto arr = finish( make_array<T>[{1}][{2}[]{3}][{4}][{5}] );
这些看起来都不是好的解决方案。
使用variardics会限制您对编译器施加的varargs数量限制，并阻止递归使用{}作为子结构。
最后，确实没有一个好的解决方案。
我所做的是编写代码，因此它会同时消耗T[]和std::array数据 - 它并不关心我提供哪些代码。有时这意味着我的转发代码必须小心谨慎地将[]数组转换为std::array。