Sollte Vector3 von Vector2 erben?

Ich erstelle ein paar Klassen Vector2(X & Y) und Vector3(X, Y & Z), aber ich weiß nicht , ob machen Vector3von erben Vector2, oder ob neu implementieren die Membervariablen m_xund m_ywieder? Was sind die Vor- und Nachteile jeder Seite (Vererbung vs. Neudefinition)?

Bearbeiten: Ich verwende C ++ (VS2010).

Nein, sollte es nicht. Das einzige, was Sie aus der Vererbung verwenden würden, sind die Komponenten xund y. Die in einer Vector2Klasse verwendeten Methoden wären in einer Klasse nicht nützlich Vector3. Sie würden wahrscheinlich unterschiedliche Argumente verwenden und Operationen mit einer unterschiedlichen Anzahl von Mitgliedsvariablen ausführen.

Mit C ++ können Sie eine kuriose Sache machen (Sie haben keine Sprache angegeben, und diese Antwort ist hauptsächlich deshalb so, weil ich finde, dass es schön ist, Alternativen zu sehen, obwohl ich glaube, dass dies in den meisten Fällen nicht wirklich nützlich ist.)

Mit Vorlagen können Sie Folgendes tun:

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;
        }
};

und das kann so verwendet werden:

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

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

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

Wie gesagt, ich halte dies für nicht nützlich und es wird wahrscheinlich Ihr Leben verkomplizieren, wenn Sie versuchen, Punkte / Normalisierungen / andere Dinge zu implementieren und generisch mit einer beliebigen Anzahl von Vektoren zu arbeiten.

Unabhängig von der Geschwindigkeit ist die erste Frage, die Sie sich stellen sollten, wenn Sie eine Vererbung durchführen, ob Sie sie polymorph verwenden werden. Genauer gesagt, gibt es eine Situation, in der Sie sich vorstellen können, wie Sie a verwenden, Vector3als wäre es ein Vector2(was Sie explizit sagen, wenn Sie davon erben, dass ein Vektor3 ein Vektor2 ist).

Wenn nicht, sollten Sie keine Vererbung verwenden. Sie sollten keine Vererbung verwenden, um Code freizugeben. Dafür sind Komponenten und externe Funktionen gedacht, nicht dass Sie irgendeinen Code zwischen ihnen teilen würden.

That being said, können Sie einfache Möglichkeiten wollen convert Vector3 s Vector2s, und in diesem Fall können Sie einen Operator Überlastung schreiben, die implizit gestutzt werden , Vector3um einen Vector2. Aber du solltest nicht erben.

Nein, da auch jede Methode überschrieben werden muss, können Sie nicht wirklich davon erben.

Wenn überhaupt, könnten beide eine Vector-Schnittstelle implementieren. Da Sie jedoch wahrscheinlich nicht / sub / dot / dst zwischen einem Vector2 und einem Vector3 hinzufügen möchten, hat dies unerwünschte Nebenwirkungen. Und verschiedene Parameter usw. zu haben, wäre ein Ärger.
Daher kann ich in diesem Fall wirklich keine Vorteile der Vererbung / Schnittstelle erkennen.

Ein Beispiel ist das Libgdx-Framework, bei dem Vector2 und Vector3 nichts anderes miteinander zu tun haben als die gleichen Methoden.

Wenn Sie vorhaben, SIMD- Arrays zu verwenden, sind diese wahrscheinlich die besten. Wenn Sie die Operatorüberladung dennoch verwenden möchten, können Sie erwägen, ein Interface / Mixin zu verwenden, um auf das zugrunde liegende Array zuzugreifen. Hier ist beispielsweise ein Ausgangspunkt, der nur das (nicht getestete) enthält Add.

Beachten Sie, wie ich habe nicht vorgesehen X/ Y/ Zjede VectorXKlasse erben würde direkt von diesem - aus den gleichen Gründen von anderen Menschen angegeben. Trotzdem habe ich Arrays gesehen, die oft in freier Wildbahn als Vektoren verwendet wurden.

#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);
    }
};

Haftungsausschluss: Mein C ++ könnte scheiße sein, es ist schon eine Weile her, seit ich es benutzt habe.

Ein weiterer schwerwiegender Nachteil, wenn Vec3 von Vec2 erbt oder wenn beide von einer einzigen Vector-Klasse erben: Ihr Code wird viel bewirkenvon Operationen an Vektoren, oft in zeitkritischen Situationen, und es liegt sehr in Ihrem Interesse, sicherzustellen, dass all diese Operationen so schnell wie möglich sind - viel mehr als bei vielen anderen Objekten, die dies nicht tun ganz so universell oder niedrig. Während ein guter Compiler sein Bestes tut, um den Vererbungsaufwand zu reduzieren, verlassen Sie sich immer noch mehr auf den Compiler, als Sie möchten. Stattdessen würde ich sie als Strukturen mit so wenig Aufwand wie möglich erstellen und möglicherweise sogar versuchen, die meisten Funktionen, die sie verwenden (mit Ausnahme von Dingen wie operator +, denen nicht wirklich geholfen werden kann), als globale statt als Methoden zu definieren struct. Eine frühzeitige Optimierung wird generell gegen und aus gutem Grund empfohlen,