C++ 三维数学模板向量类的代码重用问题

我有一个3D向量数学的模板向量类。我希望有不同类型和大小的此类变体（例如，Vec2i、Vec2f、Vec3i、Vec3f），并能够从另一个变体构建一个变体，如下所示：

Vec2i v(1, 2);
Vec3f u = Vec3f(v, 0);

目前，我在Vector中有许多构造函数来实现这一点。但是，允许以与上述相同的方式构造Vec4似乎是不正确的：

Vec4f t = Vec3f(v, 0)

---

我希望为Vec2*、Vec3*、Vec4*变体提供单独的类，但这意味着代码重复。我该怎么做？从基向量类继承？根据原始向量类实现每个变量（即向量类是每个变量的私有成员）？

使用模板。这完全没有经过测试

template <int N>
struct Vec
{
    Vec(const Vec<N - 1>& smaller_vec, double v) { std::copy(&smaller_vec.values[0], &smaller_vec.values[0] + N-1, &values[0]); values[N-1] = v; }

    double values[N];
};

template <>
struct Vec<1>
{
    Vec(double v) { values[0] = v; }

    double values[1];
};

Vec<3> v3(Vec<2>(Vec<1>(5), 6), 7);

模板
结构向量
{
向量（常量向量和较小向量，双v）{std:：copy（&较小向量值[0]，&较小向量值[0]+N-1，&值[0]）；值[N-1]=v；}
双值[N]；
};
模板
结构向量
{
向量（双v）{values[0]=v；}
双值[1]；
};
Vec-v3（Vec（5,6,7））；

在我看来，Vec2和Vec3是完全不同的，如果它们相互关联，您会期望什么样的代码重用

对于不同的内置类型，只需使用模板类和模板构造函数：

template<typename T1> 
struct Vec2 {
    Vec2(T1 const & X, T1 const & Y) : x(X), y(Y) {}
    template <typename T2> 
    Vec2(Vec2<T2> const & V) {
        x = static_cast<T1>(V.x);
        y = static_cast<T1>(V.y);
    }

    T1 x, y;
};


template<typename T1> 
struct Vec3 {
    Vec3(T1 const & X, T1 const & Y, T1 const & Z) : x(X), y(Y), z(Z) {}
    template <typename T2> 
    Vec3(Vec3<T2> const & V) {
        x = static_cast<T1>(V.x); 
        y = static_cast<T1>(V.y);
        z = static_cast<T1>(V.z);
    }
    template <typename T2, typename T3> 
    Vec3(Vec2<T2> const & V, T3 const & Z) {
        x = static_cast<T1>(V.x);
        y = static_cast<T1>(V.y);
        z = static_cast<T1>(Z);
    }

    T1 x, y, z;
};

模板
结构向量2{
Vec2（T1常数X，T1常数Y）：X（X），Y（Y）{
模板
Vec2（Vec2常量和V）{
x=静态_铸件（V.x）；
y=静态铸件（V.y）；
}
T1×y；
};
模板
结构向量3{
Vec3（T1常数与X，T1常数与Y，T1常数与Z）：X（X），Y（Y），Z（Z）{}
模板
Vec3（Vec3常量和V）{
x=静态_铸件（V.x）；
y=静态铸件（V.y）；
z=静态_铸造（V.z）；
}
模板
Vec3（Vec2常量和V、T3常量和Z）{
x=静态_铸件（V.x）；
y=静态铸件（V.y）；
z=静态_铸造（z）；
}
T1 x，y，z；
};

如果要使Vec2和Vec3相关，请让Vec3模板继承Vec2模板，然后隐藏需要为Vec3重写的函数。

类似的内容

template <int size, typename T>
struct Vec
{
    Vec<size, T>() {}
    Vec<size, T>(Vec<size-1, T>, T val) {} // here's the fun
};

typedef Vec<2, float> Vec2f;
typedef Vec<3, float> Vec3f;
typedef Vec<4, float> Vec4f;
// ...

int main()
{
    Vec2f john;
    Vec3f casey(john, 0);
    Vec4f chuck(casey, 0);

    return 0;
}

模板
结构向量
{
Vec（）{}
Vec（Vec，T val）{}//有趣的是
};
类型定义向量向量向量2F；
typedef-Vec-Vec3f；
typedef-Vec-Vec4f；
// ...
int main（）
{
约翰；
Vec3f凯西（约翰，0）；
Vec4f卡盘（凯西，0）；
返回0；
}

我最终做了类似的事情；我创建了一个基本的向量类，Vec2、Vec3、Vec4、Point2和Point3根据它实现，以便重用向量功能，但只公开其操作的子集（如Point2和Point3）或添加功能（专用构造函数）。