Vector3はVector2を継承する必要がありますか？

私はクラスのカップル作成していますVector2（X＆Y）をし、Vector3（X、Y＆Z）が、私はするかどうかわかりませんVector3から継承するVector2、またはにするかどうかのメンバ変数を再実装するm_xとm_y、再び？それぞれの長所と短所は何ですか（継承と再定義）。

編集： C ++（VS2010）を使用しています。

いいえ、できません。あなたが相続から使用しているだろう唯一のものはあるxと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;
}

私が言ったように、これは有用ではないと思います。そして、ドット/正規化/他のものを実装して、任意の数のベクトルでジェネリックにしようとすると、おそらくあなたの人生を複雑にします。

やったときに速度に関係なく、最初の質問は、あなたは自問しなければならないすべてのあなたが多形、それらを使用しているつもりなら継承があります。より具体的には、a Vector3を使用して自分自身をaであるかのように見ることができる状況がありますVector2（これを継承することにより、Vector3が「is-a」Vector2であることを明示的に言っています）。

そうでない場合は、継承を使用しないでください。コードを共有するために継承を使用しないでください。それがコンポーネントと外部関数の目的です。とにかくそれらの間でコードを共有するわけではありません。

そうは言っても、sをs に変換する 簡単な方法が必要な場合があります。その場合、暗黙的にaを切り捨てる演算子オーバーロードを記述できます。しかし、継承すべきではありません。 Vector3Vector2Vector3Vector2

いいえ、すべてのメソッドをオーバーライドする必要があるため、実際に継承する方法は使用できません。

どちらかといえば、両方とも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 ++は使い物にならないかもしれません。使用してからしばらく経ちました。

Vec3をVec2から継承すること、またはおそらく両方を単一のVectorクラスから継承することに対するもう1つの重大な欠点：コードは多くのことを行います多くの場合、タイムクリティカルな状況でのベクトルの操作、およびこれらの操作のすべてが可能な限り高速であることを確認することは非常に重要です-他の多くのオブジェクトではない非常に普遍的または低レベルです。優れたコンパイラーは、継承のオーバーヘッドをフラット化するために最善を尽くしますが、それでもコンパイラーへの依存度は自分が望んでいる以上です。代わりに、できるだけオーバーヘッドの少ない構造体として構築し、おそらくそれらを使用する関数のほとんど（実際には役に立たないoperator +のようなものを除く）を、構造体。通常、早期の最適化が推奨されますが、理由はありますが、