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

내가 말했듯이, 이것이 유용하지 않다고 생각하고 도트 / 정규화 / 다른 것들을 구현하려고 시도하고 많은 수의 벡터와 일반화하려고하면 인생이 복잡해질 것입니다.

할 때에 관계없이 속도, 첫 번째 질문은 당신 자신에게 물어 봐야 어떤 당신이 다형을 사용하는 거라면 상속입니다. 좀 더 구체적으로 말하자면, Vector3마치 마치 마치 Vector2(Vector3 "is-a"Vector2라고 명시 적으로 말하는 것처럼) 자신을 사용하여 자신을 볼 수있는 상황이 있습니까 ?

그렇지 않으면 상속을 사용하지 않아야합니다. 코드를 공유하기 위해 상속을 사용해서는 안됩니다. 그것이 컴포넌트와 외부 함수를위한 것입니다. 어쨌든 그들 사이에 코드를 공유하지 않을 것입니다.

즉, 당신은 쉬운 방법을 원할 수 있습니다 변환 Vector3 에의 Vector2의를, 그 경우 당신은 암시 적으로 자릅니다 운영자 과부하 쓸 수 Vector3A를을 Vector2. 그러나 당신은 상속해서는 안됩니다.

아니요, 모든 메서드를 재정의해야하므로 실제로 상속 할 필요가 없습니다.

무언가라면, 벡터 인터페이스를 모두 구현할 수 있습니다. 그러나 Vector2와 Vector3 사이에 추가 / 하위 / 도트 / 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 클래스에서 상속받는 데 대한 또 다른 심각한 단점 : 코드가 많이 수행됩니다.벡터에 대한 작업, 종종 시간이 중요한 상황에서 이러한 작업을 최대한 빨리 수행하는 것이 최선의 이익입니다. 그렇지 않은 다른 많은 개체보다 훨씬 빠릅니다. 매우 보편적이거나 저수준입니다. 좋은 컴파일러는 상속 오버 헤드를 평탄화하기 위해 최선을 다하지만, 여전히 원하는 컴파일러보다 더 많은 컴파일러에 의존하고 있습니다. 대신 가능한 한 적은 오버 헤드로 구조체로 빌드하고 가능한 경우 (실제로 도움이 될 수없는 operator +와 같은 것을 제외하고) 함수를 사용하는 대부분의 함수를 시도하고 만들 수 있습니다. 구조체. 조기 최적화는 일반적으로 권장되며 탁월한 이유가 있습니다.