Überladen von Operatoren

LukeS

Erfahrenes Mitglied
Hallo zusammen

Eine kleine Frage:
Ist es möglich den Index-Operator [] doppelt zu überladen, dass ich ihn so verwenden kann:
Code:
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
 
Ist möglich. Bzw. nicht soo einfach wie du es gern hättest, aber es geht, ja. Man nutzt dafür Proxy-Objekte.

C++:
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!
 
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
 
Zurück