Haruskah Vector3 mewarisi dari Vector2?

Saya membuat beberapa kelas Vector2(X & Y) dan Vector3(X, Y & Z), tetapi saya tidak tahu apakah akan Vector3mewarisi Vector2, atau apakah akan mengimplementasikan kembali variabel anggota m_xdan m_ylagi? Apa pro dan kontra dari masing-masing pihak (warisan vs redefinisi).

Sunting: Saya menggunakan C ++ (VS2010).

Tidak seharusnya tidak. Satu-satunya hal yang akan Anda gunakan dari warisan adalah xdan ykomponen. Metode yang digunakan di Vector2kelas tidak akan berguna di Vector3kelas, mereka kemungkinan akan mengambil argumen yang berbeda dan melakukan operasi pada sejumlah variabel anggota yang berbeda.

Ada hal aneh yang dapat Anda lakukan dengan C ++ (Anda tidak menentukan bahasa, dan jawaban ini sebagian besar karena saya pikir senang melihat alternatif, meskipun saya tidak benar-benar percaya ini berguna dalam kebanyakan kasus.)

Menggunakan templat Anda dapat melakukan sesuatu seperti ini:

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

dan ini bisa digunakan seperti ini:

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

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

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

Seperti yang saya katakan, saya tidak berpikir ini berguna, dan itu mungkin akan mempersulit hidup Anda ketika Anda mencoba menerapkan dot / menormalkan / hal-hal lain dan mencoba untuk menjadi generik dengan sejumlah vektor.

Terlepas dari kecepatan, pertanyaan pertama yang harus Anda bertanya pada diri sendiri ketika melakukan setiap warisan adalah jika Anda akan menggunakan mereka polymorphically. Lebih khusus lagi, apakah ada situasi di mana Anda dapat melihat diri Anda menggunakan Vector3seolah-olah itu Vector2(yang, dengan mewarisi darinya, Anda secara eksplisit mengatakan bahwa Vector3 "is-a" Vector2).

Jika tidak, maka Anda tidak harus menggunakan warisan. Anda seharusnya tidak menggunakan warisan untuk membagikan kode. Itulah gunanya komponen dan fungsi eksternal, bukan berarti Anda akan membagikan kode apa pun di antara mereka.

Yang sedang berkata, Anda mungkin ingin cara mudah untuk mengubah Vector3 s ke Vector2s, dan dalam hal ini Anda dapat menulis operator yang berlebihan yang secara implisit akan memotong Vector3ke a Vector2. Tetapi Anda tidak seharusnya mewarisi.

Tidak, karena setiap metode perlu ditimpa juga, Anda tidak akan menggunakan pewarisan darinya.

Jika ada sesuatu, mereka berdua bisa mengimplementasikan antarmuka vektor. Namun, karena Anda mungkin tidak ingin menambahkan / sub / dot / dst antara Vector2 dan Vector3 ini akan memiliki efek samping yang tidak diinginkan. Dan memiliki parameter yang berbeda dll akan merepotkan.
Jadi saya benar-benar tidak dapat melihat pro dari warisan / antarmuka dalam hal ini.

Contohnya adalah kerangka Libgdx, di mana Vector2 dan Vector3 tidak ada hubungannya satu sama lain, selain memiliki jenis metode yang sama.

Jika Anda berencana untuk menggunakan array SIMD kemungkinan yang terbaik. Jika Anda masih ingin menggunakan overloading operator, Anda dapat mempertimbangkan untuk menggunakan antarmuka / mixin untuk mengakses array yang mendasarinya - misalnya, di sini adalah titik awal yang hanya memiliki (belum teruji) Add.

Perhatikan bagaimana saya belum memberikan X/ Y/ Z, masing-masing VectorXkelas akan mewarisi langsung dari satu ini - untuk alasan yang sama yang ditentukan oleh orang lain. Namun, saya telah melihat array yang digunakan sebagai vektor berkali-kali di alam liar.

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

Penafian: C ++ saya mungkin payah, sudah lama sejak saya menggunakannya.

Lain con serius untuk memiliki Vec3 mewarisi dari Vec2 atau, bisa dibilang, untuk memiliki kedua mewarisi dari kelas Vector tunggal: kode Anda akan melakukan banyakoperasi pada vektor, sering dalam situasi kritis waktu, dan sangat penting bagi Anda untuk memastikan bahwa semua operasi itu secepat mungkin - jauh lebih banyak daripada banyak objek lain yang tidak cukup universal atau level rendah. Walaupun kompiler yang baik akan melakukan yang terbaik untuk meratakan overhead warisan, Anda masih lebih mengandalkan kompiler di sana daripada yang Anda inginkan; sebagai gantinya, saya akan membangun mereka sebagai struct dengan overhead sesedikit mungkin dan bahkan mungkin mencoba dan membuat sebagian besar fungsi yang menggunakannya (dengan pengecualian hal-hal seperti operator + yang tidak dapat membantu) menjadi global daripada metode pada struct. Optimalisasi awal umumnya direkomendasikan, dan dengan alasan yang sangat baik,