C++ 模拟递归定义的类数组的聚合初始化

考虑：

template <std::size_t r,std::size_t d>
struct Tensor
{
  Tensor<r-1u,d> Data[d];
};

template <std::size_t d>
struct Tensor<0u,d>
{
  double Data;
};

注意大括号省略

这也适用于一般编程环境，例如：

模板
张量MakeTensor（T…x）{return{x…}；}

但是，如果

数据

是私有的，

张量

将不再是聚合，因此上述语法将无效

---

在这种情况下，是否可以通过编程方式恢复此行为？

聚合初始化将仅对聚合起作用，因此严格来说，这是不可能的

您可以通过提供初始值设定项列表/可变模板构造函数，或通过仅为初始化目的而获取张量数据结构聚合版本的构造函数来模拟它，例如：

template <std::size_t r,std::size_t d>
struct RawTensor
{
  std::array<RawTensor<r-1u,d>,d> data;
};

template <std::size_t d>
struct RawTensor<0u,d>
{
  double data;
};

template <std::size_t r,std::size_t d>
struct Tensor
{
  Tensor( RawTensor<r,d> const& data ): data_{data}{}

private:
  RawTensor<r,d> data_;
};

template <typename... T,
typename= std::enable_if_t<(std::is_same_v<T,double> && ...) && (sizeof...(T)==9u)>>
RawTensor<2u,3u> MakeTensor(T... x) { return {x...}; }

Tensor<2u,3u> t1 = RawTensor<2u,3u>{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
Tensor<2u,3u> t2 = MakeTensor( 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 );

模板
结构张量
{
std：：数组数据；
};
模板
结构张量
{
双重数据；
};
模板
结构张量
{
张量（RawTensor const&data）：数据{data}{
私人：
拉维张量数据；
};
模板
RawTensor MakeTensor（T…x）{return{x..}；}
张量t1=RawTensor{1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0}；
张量t2=MakeTensor（1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0）；

---

并让编译器对其进行优化。如果您的初衷是利用运算符[]的链接（因此您需要嵌套数据为张量类型），则仍然可以，但需要一个不那么琐碎的初始化逻辑。

聚合初始化只适用于聚合，因此严格来说，这是不可能的

您可以通过提供初始值设定项列表/可变模板构造函数，或通过仅为初始化目的而获取张量数据结构聚合版本的构造函数来模拟它，例如：

template <std::size_t r,std::size_t d>
struct RawTensor
{
  std::array<RawTensor<r-1u,d>,d> data;
};

template <std::size_t d>
struct RawTensor<0u,d>
{
  double data;
};

template <std::size_t r,std::size_t d>
struct Tensor
{
  Tensor( RawTensor<r,d> const& data ): data_{data}{}

private:
  RawTensor<r,d> data_;
};

template <typename... T,
typename= std::enable_if_t<(std::is_same_v<T,double> && ...) && (sizeof...(T)==9u)>>
RawTensor<2u,3u> MakeTensor(T... x) { return {x...}; }

Tensor<2u,3u> t1 = RawTensor<2u,3u>{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
Tensor<2u,3u> t2 = MakeTensor( 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 );

模板
结构张量
{
std：：数组数据；
};
模板
结构张量
{
双重数据；
};
模板
结构张量
{
张量（RawTensor const&data）：数据{data}{
私人：
拉维张量数据；
};
模板
RawTensor MakeTensor（T…x）{return{x..}；}
张量t1=RawTensor{1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0}；
张量t2=MakeTensor（1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0）；

---

并让编译器对其进行优化。如果您的初衷是利用运算符[]的链接（因此您需要嵌套数据为张量类型），则仍然可以，但需要一个不那么繁琐的初始化逻辑。

聚合初始化需要聚合，因此严格来说，不需要；您可以通过初始值设定项\列表构造函数来模拟它。。。或者是一个构造函数，它获取仅用于初始化的张量数据结构的聚合版本purposes@MassimilianoJanes对那可能行得通。可能将

Tensor

重命名为

TensorData

，以便实际的Tensor具有

TensorData

的私有实例和适当的构造函数。你想详细说明一下答案吗？好的，等一下：）…聚合初始化需要一个聚合，所以严格来说，不需要；您可以通过初始值设定项\列表构造函数来模拟它。。。或者是一个构造函数，它获取仅用于初始化的张量数据结构的聚合版本purposes@MassimilianoJanes对那可能行得通。可能将

Tensor

重命名为

TensorData

，以便实际的Tensor具有

TensorData

的私有实例和适当的构造函数。你想详细说明一下答案吗？好的，等一下：）。。。

template <std::size_t r,std::size_t d>
struct RawTensor
{
  std::array<RawTensor<r-1u,d>,d> data;
};

template <std::size_t d>
struct RawTensor<0u,d>
{
  double data;
};

template <std::size_t r,std::size_t d>
struct Tensor
{
  Tensor( RawTensor<r,d> const& data ): data_{data}{}

private:
  RawTensor<r,d> data_;
};

template <typename... T,
typename= std::enable_if_t<(std::is_same_v<T,double> && ...) && (sizeof...(T)==9u)>>
RawTensor<2u,3u> MakeTensor(T... x) { return {x...}; }

Tensor<2u,3u> t1 = RawTensor<2u,3u>{ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 };
Tensor<2u,3u> t2 = MakeTensor( 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 );