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

อย่างที่ฉันบอกไปฉันไม่คิดว่ามันจะมีประโยชน์และมันอาจจะทำให้ชีวิตคุณซับซ้อนขึ้นเมื่อคุณพยายามที่จะใช้จุด / ปกติ / สิ่งอื่น ๆ และพยายามที่จะใช้สามัญกับเวกเตอร์จำนวนเท่าใดก็ได้

โดยไม่คำนึงถึงความเร็วคำถามแรกที่คุณควรถามตัวเองเมื่อทำการรับมรดกใด ๆคือถ้าคุณกำลังจะใช้พวกเขา polymorphically โดยเฉพาะอย่างยิ่งมีสถานการณ์ใดบ้างที่คุณสามารถเห็นตัวเองโดยใช้ a Vector3ราวกับว่ามันเป็นVector2(ซึ่งโดยการสืบทอดจากมันคุณกำลังพูดอย่างชัดเจนว่า Vector3 "เป็น -a" Vector2)

ถ้าไม่เช่นนั้นคุณไม่ควรใช้การสืบทอด คุณไม่ควรใช้การสืบทอดเพื่อแบ่งปันรหัส นั่นคือสิ่งที่องค์ประกอบและฟังก์ชั่นภายนอกมีไว้เพื่อมิให้คุณแชร์รหัสระหว่างกัน

ที่ถูกกล่าวว่าคุณอาจต้องการวิธีที่ง่ายต่อการแปลง Vector3เพื่อVector2s และในกรณีที่คุณสามารถเขียนเกินที่ผู้ประกอบการโดยปริยายจะตัดไปVector3 Vector2แต่คุณไม่ควรรับช่วง

ไม่เพราะทุกวิธีจะต้องถูกแทนที่ด้วยเช่นกันคุณจะไม่ได้รับมรดกจากมันจริง ๆ

ถ้ามีอะไรพวกเขาทั้งคู่ก็สามารถใช้ Vector interface ได้ อย่างไรก็ตามเนื่องจากคุณอาจไม่ต้องการเพิ่ม / sub / dot / dst ระหว่าง Vector2 และ Vector3 สิ่งนี้จะมีผลข้างเคียงที่ไม่พึงประสงค์ และการมีพารามิเตอร์ที่แตกต่างกันเป็นต้นจะทำให้เกิดความยุ่งยาก
ดังนั้นฉันจึงไม่เห็นข้อดีของการสืบทอด / ส่วนต่อประสานในกรณีนี้

ตัวอย่างคือกรอบ Libgdx โดยที่Vector2และVector3ไม่มีส่วนเกี่ยวข้องกันนอกจากวิธีการชนิดเดียวกัน

หากคุณวางแผนที่จะใช้ SIMD Arrayนั้นน่าจะดีที่สุด หากคุณยังต้องการใช้โอเปอเรเตอร์การบรรทุกเกินพิกัดคุณสามารถพิจารณาใช้อินเทอร์เฟซ / มิกซ์อินเพื่อเข้าถึงอาร์เรย์ต้นแบบ - ตัวอย่างเช่นนี่คือจุดเริ่มต้นที่มี (ไม่ได้ทดสอบ) 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 หรือเพื่อให้มีทั้งการสืบทอดจากคลาสเวกเตอร์เดียว: รหัสของคุณจะทำมากของการดำเนินการเกี่ยวกับเวกเตอร์มักจะอยู่ในสถานการณ์ที่สำคัญและเป็นประโยชน์มากที่สุดของคุณเพื่อให้แน่ใจว่าการดำเนินการทั้งหมดนั้นเร็วเท่าที่จะเป็นไปได้ - มากกว่าสิ่งอื่น ๆ ที่ไม่ใช่ ค่อนข้างสากลหรือระดับต่ำ ในขณะที่คอมไพเลอร์ที่ดีจะพยายามอย่างดีที่สุดในการทำให้ค่าใช้จ่ายในการสืบทอดนั้นราบรื่น แต่คุณยังต้องพึ่งพาคอมไพเลอร์มากกว่าที่คุณต้องการ ฉันจะสร้างพวกเขาเป็น structs โดยให้ค่าใช้จ่ายน้อยที่สุดเท่าที่จะเป็นไปได้และอาจลองใช้ฟังก์ชั่นส่วนใหญ่ที่ใช้งานพวกเขา (ยกเว้นสิ่งต่าง ๆ เช่นโอเปอเรเตอร์ + ซึ่งไม่สามารถช่วยได้จริง ๆ ) struct โดยทั่วไปมักจะแนะนำให้ใช้การปรับให้เหมาะสมที่สุดและด้วยเหตุผลที่ยอดเยี่ยม