Vector3应该继承Vector2吗？

我创建了几个类别Vector2（X＆Y）和Vector3（X，Y，Z），但我不知道是否进行Vector3继承Vector2，还是重新实现成员变量m_x和m_y一次？双方的优缺点是什么（继承与重新定义）。

编辑：我正在使用C ++（VS2010）。

不，不应该。从继承中唯一要使用的是xand y组件。Vector2类中使用的方法在类中不是有用的Vector3，它们可能采用不同的参数并对不同数量的成员变量执行操作。

使用C ++可以做一个奇怪的事情（您没有指定语言，并且这个答案主要是因为我认为很高兴看到替代方法，尽管我真的不认为这在大多数情况下很有用。）

使用模板，您可以执行以下操作：

template <class T, class S, int U>
class VectorN
{
    protected:
        int _vec[U];
    public:
        S& operator+=(const S c)
        {
            for(int i = 0; i < U; i++)
            {
                _vec[i] += c.at(i);
            }
            return (S&)*this;
        }
        int at(int n) const
        {
            return _vec[n];
        }
};

template <class T>
class Vec2 : public VectorN<T,Vec2<T>,2>
{
    public:
        T& x;
        T& y;
        Vec2(T a, T b) : x(this->_vec[0]), y(this->_vec[1])
        {
            this->_vec[0] = a;
            this->_vec[1] = b;
        }
};

template <class T>
class Vec3 : public VectorN<T,Vec3<T>,3>
{
    public:
        T& x;
        T& y;
        T& z;
        Vec3(T a, T b, T c) : x(this->_vec[0]), y(this->_vec[1]), z(this->_vec[2])
        {
            this->_vec[0] = a;
            this->_vec[1] = b;
            this->_vec[2] = c;
        }
};

可以这样使用：

int main(int argc, char* argv[])
{

    Vec2<int> v1(5,0);
    Vec2<int> v2(10,1);

    std::cout<<((v1+=v2)+=v2).x;
    return 0;
}

就像我说的那样，我认为这没有用，当您尝试实现点/归一化/其他内容并尝试与任意数量的向量通用时，这可能会使您的生活变得复杂。

无论速度如何，执行任何继承时应该问自己的第一个问题是，是否要多态使用它们。更具体地说，在任何情况下，您都可以看到自己Vector3好像使用a 一样Vector2（通过继承它，您是在明确地说Vector3是“ is-a” Vector2）。

如果没有，那么您不应该使用继承。您不应该使用继承来共享代码。那就是组件和外部功能的目的，而不是您要在它们之间共享任何代码。

话虽这么说，您可能需要简单的方法将 Vector3 s 转换为Vector2s，在这种情况下，您可以编写运算符重载，将其隐式截断Vector3为Vector2。但是你不应该继承。

不可以，因为每个方法都需要被覆盖，因此您将无法实际使用它。

如果有的话，他们都可以实现Vector接口。但是，由于您可能不想在Vector2和Vector3之间添加/ sub / dot / dst，因此会有不良的副作用。并且具有不同的参数等将是麻烦的。
因此，在这种情况下，我真的看不到任何继承/接口的优点。

一个例子是Libgdx框架，其中Vector2和Vector3除了具有相同类型的方法外，彼此无关。

如果您打算使用SIMD 阵列，则可能是最好的选择。如果仍然希望使用运算符重载，则可以考虑使用接口/混合来访问基础数组-例如，这里是一个仅包含（未测试）的起点Add。

请注意我如何不提供X/ Y/ Z，每个VectorX班级将直接从这个继承-由其他人指定同样的原因。不过，我在野外多次看到数组用作向量。

#include <xmmintrin.h>

class Vector
{
public:
    Vector(void)
    {
        Values = AllocArray();
    }

    virtual ~Vector(void) 
    { 
        _aligned_free(Values);
    }

    // Gets a pointer to the array that contains the vector.
    float* GetVector()
    {
        return Values;
    }

    // Gets the number of dimensions contained by the vector.
    virtual char GetDimensions() = 0;

    // An example of how the Vector2 Add would look.
    Vector2 operator+ (const Vector2& other)
    {
        return Vector2(Add(other.Values));
    }

protected:
    Vector(float* values)
    {
        // Assume it was created correctly.
        Values = values;
    }

    // The array of values in the vector.
    float* Values;

    // Adds another vector to this one (this + other)
    float* Add(float* other)
    {
        float* r = AllocArray();

#if SSE
        __m128 pv1 = _mm_load_ps(Values);
        __m128 pv2 = _mm_load_ps(other);
        __m128 pvr = _mm_load_ps(r);

        pvr = _mm_add_ps(pv1, pv2);
        _mm_store_ps(r, pvr);

#else
        char dims = GetDimensions();
        for(char i = 0; i < dims; i++)
            r[i] = Values[i] + other[i];
#endif

        return r;
    }

private:

    float* AllocArray()
    {
        // SSE float arrays need to be 16-byte aligned.
        return (float*) _aligned_malloc(GetDimensions() * sizeof(float), 16);
    }
};

免责声明：我的C ++可能很烂，自使用以来已经有一段时间了。

从Vec2继承Vec3的另一个严重缺点，或者可以说，从一个Vector类继承这两者是另一个严重的缺点：您的代码将做很多事情向量，通常在时间紧迫的情况下进行，并且确保所有这些操作尽可能的快是非常符合您的最大利益的，这要比对许多其他非对象的操作要快得多非常普遍或低级。一个好的编译器会尽力消除所有继承开销，但是您仍然比那里想要的更多地依赖编译器。相反，我会以尽可能少的开销将它们构建为结构，甚至可能尝试使使用它们的大多数功能（除了operator +之类的东西无法真正帮助）是全局的，而不是全局的方法。结构。通常建议针对优化，并且有充分的理由，