#include <stdlib.h>
#include <list>

template<class T>
class Matriz {
private:
    size_t filas;
    size_t columnas;
    std::list< std::list<T> > matriz;
public:
    Matriz();
    void agregar_fila();
    void agregar_columna();
    size_t obtener_cantidad_filas();
    size_t obtener_cantidad_columnas();

    // Todos devuelven un booleano indicando si la fila y columna recibidas
    // están dentro de la matriz.
    bool agregar_elemento(T& elem, size_t fila, size_t columna);
    bool obtener_elemento(size_t fila, size_t columna, T& elem);
    bool eliminar_elemento(size_t fila, size_t columna);

    bool contiene_elemento(T& elem);

    ~Matriz();
};

/*
Los operadores a utilizar son:
    - Constructor por default: al agregar una nueva fila o columna tenemos
        que llenarla de elementos T creador por default.
    - Asignación por copia (T& operator=(const T& elem)): al agregar un nuevo elemento debemos modificar
        el objeto T que estaba en esa posición, copiando el objeto recibido
        por referencia. Al eliminar un objeto, al objeto en esa posición de
        la matriz le asignamos por copia un nuevo elemento T construido por
        default.
    - bool operator == (const T& other) const; para el contiene_elemento.
*/

// DUDA: está bien el approach de al agregar una nueva fila o columna asignarle
// elementos T& construidos por default? Habría que mantener la cuenta de
// cantidad de elementos reales agregados a mano?