Supraincarcarea operatorului [][] in C++ creind o matrice.

Matrice.cpp

/**
    Titlu: Supraincarcarea operatorului [][] in C++ creind o matrice.
    Autor: Luca Andrei
    Ideone: http://ideone.com/y8Km37
    Descriere: De fapt operatorul [][] nu poate fi supraincarcat,
    deoarece el nu este operator )), ma contrazic pe mine ce am scris in titlu ).
    De fapt aici sunt doi operatori []. Pentru a "supraincarca" [][], avem nevoie
    sa cream 2 clase, si pentru fiecare in parte sa supraincarcam [].
    Urmariti exemplul de mai jos pentru lamurire.
/**/
#include <iostream>
using namespace std;

/**
    Mai intii vom crea clasa Vector care este doar o singura linie dintr-o matrice
/**/
class Vector {
private:
    // in m tinem numarul de elemente intr-o linie
    int m;
    
    // columns este un pointer la int
    // pe care la construirea unui Vector vom aloca m elemente pentru columns
    int* columns;
public:
    // Definim constructorul implicit, este nevoie de el obligatoriu
    // mai jos voi lamuri pentru ce
    Vector(): m(0), columns(NULL) {}

    // Definim constructorul general, anume el va aloca memorie pentru columns
    Vector(int m): m(m)
    {
        // alocam un array de m elemente
        columns = new int[m];
    }
    
    // Aici este supraincarcat unul din operatorii []
    // el va returna o referinta a unui element din tabloul columns
    int& operator [] (int j)
    {
        return columns[j];
    }
};

/**
    Acum vom crea a doua clasa Matrice. De fapt aceasta este prima clasa
    iarasi ma contrazic. )
/**/
class Matrice {
private:
    // in n tinem numarul liniilor matricei
    int n;

    // lines este un pointer la Vector
    // daca tineti minte Vector este o singura linie din matrice
    // pe care la construirea unei matrici vom aloca n Vectori pentru lines
    Vector* lines;
public:
    // Constructorul general cu 2 parametri, linii si coloane
    Matrice(int n, int m): n(n)
    {
        // alocam pentru lines n Vectori
        // utilizind new fiecare Vector este creat cu ajutorul constructorului
        // implicit. Am mentionat mai sus ca in clasa Vector constructorul implicit
        // este obligatoriu, in caz contrar compilatorul va arunca o eroare
        lines = new Vector[n];

        // mergem prin array-ul de linii creat
        // si initializam fiecare Vector cu m elemente
        for (int i = 0; i < n; ++i)
        {
            // aici folosim constructorul general pentru a crea m elemente
            // pentru fiecare linie Vector
            lines[i] = Vector(m);
        }
    }

    // Supraincarcarea operatorului al doilea []
    // el va returna referinta la Vectorul i din lines
    Vector& operator [] (int i)
    {
        return lines[i];
    }
};

int main(int argc, char const *argv[])
{
    // cream o matrice 5 pe 5
    Matrice m(5,5);

    // numeroatarea se incepe de la 0
    // m[3] va returna referinta la Vectorul 4 din m
    // m[3][3] va returna o referinta la elementul 4 din
    // vectorul m[3], deoarece m[3] returneaza referinta la Vector

    for (int i = 0; i < 5; ++i)
    {
        for (int j = 0; j < 5; ++j)
        {
            m[i][j] = i + j;
        }
    }

    for (int i = 0; i < 5; ++i)
    {
        for (int j = 0; j < 5; ++j)
        {
            cout << m[i][j] << " ";
        }
        cout << endl;
    }

    cout << endl << "That's all folks!" << endl;
    return 0;
}