为何注释实例化代码后，含C数组的构造函数初始化列表可编译？

咱们一步步拆解你遇到的问题：

1. 为什么注释掉实例化语句后代码能编译？ #

这是C++模板的延迟实例化特性在起作用。模板类的成员函数（包括你写的构造函数）只有在被实际调用的时候，编译器才会去编译它的具体实现。当你注释掉A<3> a(arr);这行代码时，A<3>这个特化版本根本没有被实例化，构造函数的代码也就不会被编译器检查——自然不会触发错误。

2. 为什么直接用数组初始化数组会报错？ #

C++里的原生数组是非可复制构造的类型，你不能直接用一个数组去初始化另一个数组。就像你第二个示例代码里的const int arr_b[3] = arr_a;一样，编译器要求数组必须用初始化列表（比如{1,2,3}）来初始化，而不是另一个数组对象。你的构造函数里arr_(arr)本质上就是在做这种非法的数组到数组的初始化，所以实例化时会报错。

3. 有没有合法调用原构造函数的方式？ #

直接用你原构造函数的写法（接受数组引用）是没办法合法初始化arr_的，因为数组不能被数组初始化。不过我们可以修改代码来实现类似的需求，有几种实用方案：

方案一：改用std::array作为成员类型 #

std::array是可复制的容器，完美适配你的场景，代码也更简洁：

#include <cstddef>
#include <array>

template <std::size_t n>
class A {
public:
  explicit A(const std::array<int, n>& arr) : arr_(arr) {  }

private:
  std::array<int, n> arr_;
};

int main(int, char**) {
  const std::array<int, 3> arr = {1, 2, 3};
  A<3> a(arr); // 现在可以正常编译

  // 也可以直接用初始化列表构造
  A<3> b({4, 5, 6});
  return 0;
}

方案二：修改构造函数为接受初始化列表或参数包 #

如果你坚持要用原生数组作为成员，可以通过初始化列表或者模板参数包来直接初始化数组：

#include <cstddef>
#include <algorithm>
#include <type_traits>

template <std::size_t n>
class A {
public:
  // 接受初始化列表，同时静态检查大小匹配
  explicit A(std::initializer_list<int> il) : arr_{} {
      static_assert(il.size() == n, "Initializer list size must match array size");
      std::copy(il.begin(), il.end(), const_cast<int*>(arr_));
      // 这里的const_cast是安全的：我们在构造阶段初始化const成员，后续不会再修改
  }

  // 接受参数包，直接用参数初始化数组
  template <typename... Args, typename = std::enable_if_t<sizeof...(Args) == n && std::conjunction_v<std::is_convertible<Args, int>...>>>
  explicit A(Args&&... args) : arr_{std::forward<Args>(args)...} {}

private:
  const int arr_[n];
};

int main(int, char**) {
  A<3> a({1, 2, 3}); // 合法调用
  A<3> b(4, 5, 6);   // 同样合法
  return 0;
}

方案三：手动复制元素（不推荐，但可行） #

如果你一定要保留原构造函数的参数形式，可以在构造函数里手动复制元素。因为arr_是const的，需要借助const_cast（仅在构造阶段使用是安全的）：

#include <cstddef>
#include <algorithm>

template <std::size_t n>
class A {
public:
  explicit A(const int (&arr)[n]) : arr_{} {
      std::copy(arr, arr + n, const_cast<int*>(arr_));
  }

private:
  const int arr_[n];
};

int main(int, char**) {
  const int arr[3] = {1, 2, 3};
  A<3> a(arr); // 现在可以正常编译
  return 0;
}

不过这种方式不如std::array优雅，毕竟原生数组的局限性本来就很多，日常开发更推荐用std::array替代原生数组。

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