C++ 是什么导致这个张量外积中的无限模板递归？

我使用张量的模板表示来实现外积

张量的基本原型如下所示：

template <int N>
struct Tensor
{
    Tensor<N - 1> x;
    Tensor<N - 1> y;
    Tensor<N - 1> z;
};

顺序

N

的张量

a

和顺序

M

的张量

B

的外积只是

a

的每个元素与

B

张量的外积。顺序张量

N

与顺序张量

1

的外积定义类似

基本情况只是两阶

1

张量（向量）的外积。除此之外，如上所述，我在MSVC中得到一个

C1202

错误：

错误C1202:递归类型或函数依赖项上下文太复杂

---

我在定义外部产品时犯了什么错误？

这为我清晰地构建了：

template<int N>
struct Tensor
{
    Tensor<N - 1> x;
    Tensor<N - 1> y;
    Tensor<N - 1> z;

    Tensor() { }

    Tensor(const Tensor<N-1>& X, const Tensor<N-1>& Y, const Tensor<N-1>& Z)
      : x(X), y(Y), z(Z)
    { }
};

template<>
struct Tensor<1>
{
    double x;
    double y;
    double z;

    Tensor() : x(), y(), z() { }
    Tensor(double x, double y, double z) : x(x), y(y), z(z)
    { }
};

template<int N, int M>
Tensor<N + M> Outer(const Tensor<N>& lhs, const Tensor<M>& rhs)
{
    Tensor<N + M> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template<int N>
Tensor<N + 1> Outer(const Tensor<N>& lhs, const Tensor<1>& rhs)
{
    Tensor<N + 1> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template<int N>
Tensor<N + 1> Outer(const Tensor<1>& lhs, const Tensor<N>& rhs)
{
    return Outer(rhs, lhs);
}

Tensor<2> Outer(const Tensor<1>& lhs, const Tensor<1>& rhs)
{
    Tensor<2> result;

    result.x.x = lhs.x * rhs.x;
    result.x.y = lhs.x * rhs.y;
    result.x.z = lhs.x * rhs.z;
    result.y.x = lhs.y * rhs.x;
    result.y.y = lhs.y * rhs.y;
    result.y.z = lhs.y * rhs.z;
    result.z.x = lhs.z * rhs.x;
    result.z.y = lhs.z * rhs.y;
    result.z.z = lhs.z * rhs.z;

    return result;
}

int main()
{
    Tensor<4> a;
    Tensor<4> b;
    Outer(a, b);
}

模板
结构张量
{
张量x；
张量y；
张量z；
张量（）{}
张量（常数张量&X，常数张量&Y，常数张量&Z）
：x（x），y（y），z（z）
{ }
};
模板
结构张量
{
双x；
双y；
双z；
张量（）：x（），y（），z（）{}
张量（双x，双y，双z）：x（x），y（y），z（z）
{ }
};
模板
外部张量（常数张量和lhs、常数张量和rhs）
{
张量结果；
结果x=外部（左侧x，右侧）；
结果y=外部（左侧、右侧）；
结果z=外部（左侧、右侧）；
返回结果；
}
模板
外部张量（常数张量和lhs、常数张量和rhs）
{
张量结果；
结果x=外部（左侧x，右侧）；
结果y=外部（左侧、右侧）；
结果z=外部（左侧、右侧）；
返回结果；
}
模板
外部张量（常数张量和lhs、常数张量和rhs）
{
返回外部（右、左）；
}
外部张量（常数张量和lhs、常数张量和rhs）
{
张量结果；
结果x.x=lhs.x*rhs.x；
结果x.y=lhs.x*rhs.y；
结果x.z=lhs.x*rhs.z；
结果y.x=lhs.y*rhs.x；
结果y.y=lhs.y*rhs.y；
结果y.z=lhs.y*rhs.z；
结果.z.x=lhs.z*rhs.x；
结果.z.y=lhs.z*rhs.y；
结果.z.z=lhs.z*rhs.z；
返回结果；
}
int main（）
{
张量a；
张量b；
外部（a、b）；
}

值得注意的变化是：

在任何

外部

重载之前，需要定义

张量

专门化

由于

Tensor

将尝试默认构造其

x

、

y

和

z

数据成员，因此

Tensor

专门化需要是可默认构造的

模板外部张量（const-Tensor&lhs，const-Tensor&rhs）

重载需要与

模板外部张量（const-Tensor&lhs，const-Tensor&rhs）

对称，或者您需要为

lhs添加一个采用
双
的重载

从

外部张量（const-Tensor&lhs，const-Tensor&rhs）

重载中删除

模板

——我们在这里重载，而不是专门化

---

在VS11测试版上对我来说效果很好。你用的是什么号码？你确定你是这方面的专家吗？使用VC10SP1。发布一篇文章。@ildjarn:这个最小的示例导致VS 2010 Ultimate SP1中出现C1202错误。@SethCarnegie:它只在标题中定义和实现，使用的版本是

N=2,3,4

。这就是问题所在。我试图编译你的代码，结果导致我的计算机崩溃。两次。因为我想确定一下。我试着把这些地方清理一下，结果很好：）我在你发布这篇文章的时候就发现了——因为我在外积之后定义了

张量的基本情况定义。抱歉，我不知道你做了修改。
template<int N>
struct Tensor
{
    Tensor<N - 1> x;
    Tensor<N - 1> y;
    Tensor<N - 1> z;

    Tensor() { }

    Tensor(const Tensor<N-1>& X, const Tensor<N-1>& Y, const Tensor<N-1>& Z)
      : x(X), y(Y), z(Z)
    { }
};

template<>
struct Tensor<1>
{
    double x;
    double y;
    double z;

    Tensor() : x(), y(), z() { }
    Tensor(double x, double y, double z) : x(x), y(y), z(z)
    { }
};

template<int N, int M>
Tensor<N + M> Outer(const Tensor<N>& lhs, const Tensor<M>& rhs)
{
    Tensor<N + M> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template<int N>
Tensor<N + 1> Outer(const Tensor<N>& lhs, const Tensor<1>& rhs)
{
    Tensor<N + 1> result;

    result.x = Outer(lhs.x, rhs);
    result.y = Outer(lhs.y, rhs);
    result.z = Outer(lhs.z, rhs);

    return result;
}

template<int N>
Tensor<N + 1> Outer(const Tensor<1>& lhs, const Tensor<N>& rhs)
{
    return Outer(rhs, lhs);
}

Tensor<2> Outer(const Tensor<1>& lhs, const Tensor<1>& rhs)
{
    Tensor<2> result;

    result.x.x = lhs.x * rhs.x;
    result.x.y = lhs.x * rhs.y;
    result.x.z = lhs.x * rhs.z;
    result.y.x = lhs.y * rhs.x;
    result.y.y = lhs.y * rhs.y;
    result.y.z = lhs.y * rhs.z;
    result.z.x = lhs.z * rhs.x;
    result.z.y = lhs.z * rhs.y;
    result.z.z = lhs.z * rhs.z;

    return result;
}

int main()
{
    Tensor<4> a;
    Tensor<4> b;
    Outer(a, b);
}