Überladen von Operatoren

[LukeS]

Hallo zusammen

Eine kleine Frage:
Ist es möglich den Index-Operator [] doppelt zu überladen, dass ich ihn so verwenden kann:

myObject[i][j];

Falls ja: wie?

Hoffentlich ist meine Frage klar. Ich habe Mühe das ganze in Worte zu fassen...

Vielen Dank...

Gruss Luke

 

[devDevil]

Ist möglich. Bzw. nicht soo einfach wie du es gern hättest, aber es geht, ja. Man nutzt dafür Proxy-Objekte.

template <typename value_type>
class 2DArray 
{
public:
    typedef std::pair<std::size_t, std::size_t> size_t;
    typedef value_type value_t;

public:
    2DArray(size_t const& size)
        : m_size(size), m_data(new value_t[size.first * size.second])
    {}
    ~2DArray()
    { delete [] m_data; }

private:
    value_t* m_data;
    size_t m_size;
    
public:
    template<typename array_type>
    class Row 
    {
        2DArray<array_type>& m_array;
        std::size_t m_row;

    public:
        explizit Row(2DArray<array_type>& data, const std::size_t row)
            : m_array(data), m_row(row) 
        {}
        typename 2DArray<array_type>::value_t& operator[](const std::size_t x) 
        { return m_array.m_data[x + m_row * m_array.m_size.first]; }
        typename 2DArray<array_type>::value_t const& operator[](const std::size_t x) const
        { return m_array.m_data[x + m_row * m_array.m_size.first]; }
    };
  
    const Row operator[](const std::size_t row) { return Row(*this, row); }
};

so könnte das aussehen. Okay ich garantier nicht, dass kein Compiler fehler drin ist, hab es jetzt schnell hier rein getippt. Sollte dir das Prinzip aber klar machen!

 

[LukeS]

Danke vielmals für die Antwort!

Ich muss das mal überdenken.
Bin nicht so fit mit Templates... aber ich sollte es schon hinkriegen.

Sonst frag ich wieder...

Danke
Luke