1. CONCEPTO

-> Se usa para meter objetos que heredan de un padre, en una matriz padre
   de la cual no se sabe cuantos hijos hay, pero se sabe que todos los hijos
   heredan de un mismo padre.

2. OBSERVACIONES

-> Para armar este tipo de matrices, se suele usar punteros triples, ya que
   de entrada no se sabe cuantos hijos hay dentro de cada casillero, entonces
   se procede a armar un puntero triple, en el cual una matriz apunta a
   un vector de punteros, los cuales tienen las direcciones de memoria de los
   posibles hijos en las posiciones [i][j], despues esos apuntan a los contenidos
   que poseen los hijos.

-> De entrada el puntero triple apunta a nullptr, también el contenido que hay
   dentro de cada casillero.

3. EJEMPLO { un mapa que guarda casilleros de distintos tipos }

-------> juego.cpp <--------
#include "juego.h"
#include <iostream>
#include <string>
#include "casillero.h"
#include "casillero_transitable.h"
#include "casillero_construible.h"
#include "casillero_inaccesible.h"

using namespace std;
const int MIN_CANTIDAD_MATERIALES = 0;
const char TERRENO = 'T';
const char CAMINO = 'C';
const char LAGO = 'L';

//Llama al constructor por defecto.
Juego::Juego(){
    this -> cantidad_filas = 0;
    this -> cantidad_columnas = 0;
    mapa = nullptr;
}

//Le asigna tamaño al mapa, cuando ya tenemos la longitud del mismo.
void Juego::reedimensionar_mapa(int cantidad_filas, int cantidad_columnas){
    this -> cantidad_filas = cantidad_filas;
    this -> cantidad_columnas = cantidad_columnas;
    mapa = new Casillero**[cantidad_filas];
    for(int i = 0; i < cantidad_filas; i++)
        mapa[i] = new Casillero *[cantidad_columnas];
    inicializar_mapa();
}

//Llena los casilleros del mapa con los objetos que heredan de casillero
void Juego::llenar_casillero(char terreno, int fil, int col){
    if(terreno == LAGO)
        mapa[fil][col] = new CasilleroInaccesible();
    else if (terreno == TERRENO)
        mapa[fil][col] = new CasilleroConstruible();
    else
        mapa[fil][col] = new CasilleroTransitable();
}

//Inicializa el mapa en nullptr.
void Juego::inicializar_mapa(){
    for(int i = 0; i < cantidad_filas; i++){
        for(int j = 0; j < cantidad_columnas; j++)
            mapa[i][j] = nullptr;
    }
}

//Elimina la memoria utilizada por la matriz polimorfica.
Juego::~Juego(){
    for (int i = 0; i < cantidad_filas; i++){            
        for (int j = 0; j < cantidad_columnas; j++)
            delete mapa[i][j];

        delete [] mapa[i];
    }
    delete [] mapa;
}

-------> juego.h <--------
#ifndef _JUEGO_H_
#define _JUEGO_H_
#include "casillero.h"
#include "inventario.h"

class Juego {

    private:

        Casillero*** mapa;
        int cantidad_filas;
        int cantidad_columnas;

    public: 

        /*
        * Post: Creará un objeto de tipo Juego dejando todos sus atributos 
        *       cargados con los valores por defecto.
        */
        Juego();

        /*
        * Post: Cambiará el tamaño del mapa.
        */
        void reedimensionar_mapa(int cantidad_filas, int cantidad_columnas);

				// Post: Llena los casilleros del mapa con los objetos que heredan de casillero
				void llenar_casillero(char terreno, int fil, int col);

        /*
        * Post: Destruirá el juego, liberando toda la memoria utilizada.
        */
        ~Juego();

    private:

        /*
        * Post: Inicializará el mapa, dejando todas sus posiciones en nullptr.
        */
        void inicializar_mapa();

};

#endif // JUEGO_H_

----> main.cpp <----

#include "juego.h"

int main(){

	int fila = 20, columna = 20;
		
	//Creo un objeto de tipo juego, usando el constructor por valor.
	Juego* juego = new Juego(fila, columna);

	//Borro memoria pedida por el juego.
	delete juego;
	
	return 0;
}