Dal C al C++/Gioco life di Conway

Di seguito il listato in C++ per un'implementazione testuale del gioco della vita.

#include <iostream>
#include <cstdlib>
#include <vector>
#include <set> 
#include <ctime>

//Ho usato quasi solo funzioni "void" perché sono mooolto più belle e perché le funzioni "normali" sono sopravvalutate.

using namespace std;
/*Ho provato a dare dei nomi a tutte le funzioni e variabili che aiutani la spiegazione di ciò che succede all'interno di tale funzione
o a cosa serve tale variabile, molti sono in inglese perché sono più brevi in inglese e perché l'inglese è una lingua più bella.*/
 
// Osservabile e osservato contemporaneamente :D, gestisce le regole "biologiche"
class Casella{
public: //accessibili dall’esterno e in ogni punto del programma.
    enum stato{vuoto=0,pieno}; //Questa è una enumerazioni, essa è esattamente come i tipi fondamentali e composti, un altro "tipo"
    //essa nello specifico tratta solo valori che possono essere assunti da una variabile enumerazione e questi
    //sono ristretti ad un insieme di valori interi costanti, ad ognuno dei quali viene associato un nome.
    typedef std::set<Casella *> Container; //Typedef ha come scopo quello di semplificare la vita, esso infatti,
    //a differenza di una dichiarazione standard troppo fastidiosa, riesce a rendere il codice moooolto più riutilizzabile 
    //tra un'implementazione e un'altra.
    typedef Container::iterator Iterator; 
 
private: //utilizzabili soltanto all’interno della classe stessa.
    stato stato_;
    int vicini_futuri;
    int vicini;
    Container osservatori;
 
public:
    Casella( const Casella::stato & s = Casella::vuoto ) //const non ha bisogno di essere spiegato.
    : stato_(s), vicini_futuri(0), vicini(0){}  
 
    //non copia gli osservatori
    Casella(const Casella& c): vicini(c.vicini),
            vicini_futuri(c.vicini_futuri), stato_(c.stato_){}
    virtual ~Casella(){}  //Virtual è un pò più difficile da spiegare...è anche questa come int, double, typedef, enum un "tipo" di dichiarazione
    //virtual però è diferso dagli altri tipi di dichiarazioni poiché consente di condizionare l’esecuzione del codice 
    //secondo il tipo dell’istanza oggetto cui si fa riferimento. Scusi se non è molto chiaro ma non ho idea di come spiegarlo...
     
    // Registra gli osservatori a cui notificare i cambiamenti
    inline void Registra(Casella& c) { //Riguardo ad "inline" non sono ancora sicuro cosa faccia, ma credo aumenti le prestazioni...
        //ma ripeto che non sono sicurissimo su questo fatto, scusi se non sono ferrato ma me l'ha consigliato di usare un amico.
        if (&c != this){ //this identifica un puntatore speciale che contiene l’indirizzo dell’istanza della classe 
        //che ha invocato il metodo.
            osservatori.insert(&c);
        }
    } 
  
 
    inline void Imposta(const Casella::stato& s){
    	stato_=s;
    }
 
    inline void Muori(){
    	if(stato_==pieno){
        Imposta(Casella::vuoto);
        Notifica(-1);//Utile per la notifica, vedi dopo.
    	}
    }
 
 
    inline void Nasci() {
    	if (stato_==vuoto){
        Imposta(Casella::pieno);
        Notifica(1);//Utile per la notifica, vedi dopo.
        }
    } 
     
    // Aggiorna 
    inline void Ciclo() {
       vicini=vicini_futuri;
    }
 
    // Regole del gioco
    inline void Verifica() {
        if (stato_==pieno){
        	if (vicini<2 || vicini>3) // Modificare questa riga per cambiare le regole di morte
            	Muori();
        }else {
            if (vicini==3) // Modificare questa riga per cambiare le regole di nascita
               Nasci();
 	   }
    } 
  
    inline bool Leggi() const{
        return stato_==pieno;
    }
 
private:
    // Notifica ai vicini nascita o morte
    inline void Notifica(int msg) const{
        for (Iterator it = osservatori.begin(); it != osservatori.end(); ++it){ //A fare sta parte ci ho messo 2 giorni.
            (*it)->RiceviNotifica(msg);//Per questa infatti mi sono dovuto studiare una libreria intera.
        }
    }
     
     // Ricevi la notifica dai vicini
    inline void RiceviNotifica(int msg) {
        vicini_futuri += msg; //Stessa cosa per sta dannata parte
    }
 }; 
 
// Contenitore di caselle, che genera automaticamente le corrispondenze tra vicini. 
// Gestisce le regole "topologiche" --> termine preso da wikipedia
class Griglia{
public:
    typedef std::vector<Casella> Container;
    typedef Container::iterator Iterator;
 
private: //utilizzabili soltanto all’interno della classe stessa.
    int righe_;
    int colonne_;
    int time;
    Container griglia;
 
public: //accessibili dall’esterno e in ogni punto del programma.
    virtual ~Griglia(){}
     
    Griglia(const int& righe, const int& colonne)
    :righe_(righe), colonne_(colonne)    {
       if (righe_ < 5) righe_=5;
       if (colonne_ < 5) righe_=5;
       griglia.reserve(righe_*colonne_);
       griglia.resize(righe_*colonne_);
    }
    
    inline Casella& operator[](const int n) {
       return griglia[n];
    }
    
    inline void Cicla() {    
       for (int i = 0; i < righe_*colonne_;++i)
           griglia[i].Ciclo();
    }
 
    void Verifica(){
        for (int i = 0; i < righe_*colonne_;++i)
           griglia[i].Verifica();
     }
 
    inline void Imposta (const int& pos) {
        if ((pos >=0)&&(pos < griglia.size()))     	  
           griglia[pos].Nasci();
     }
 
    inline void Resetta (const int& pos) {
        if ((pos >=0)&&(pos < griglia.size()))	  
           griglia[pos].Muori();
     }
 
    // Modificare questa per cambiare le regole topologiche di vicinanza
    inline void Genera(){ //Scusi se questa parte è un poco incasinata ma non avevo trovato modi per scrivere più "ristretto" 
    //e comunque in un modo "chiaro e capibile".
        bool primo, ultimo;
        for (int indice=0; indice< righe_*colonne_;++indice){
        	primo = ( (indice%colonne_) == 0);
            ultimo = ( (indice%colonne_) == colonne_-1);
 
         	if (indice > colonne_){      
           		if (!primo)
              		griglia[indice].Registra(griglia[indice-colonne_ - 1]);
           		griglia[indice].Registra(griglia[indice-colonne_]);
            if (!ultimo)
              	griglia[indice].Registra(griglia[indice-colonne_ + 1]);
        }
         
        if (!primo)
           griglia[indice].Registra(griglia[indice-1]);
        if (!ultimo)
           griglia[indice].Registra(griglia[indice+1]);
    
        if (indice < ((colonne_)*(righe_-1)) ){
        	if (!ultimo)
             	griglia[indice].Registra(griglia[indice+colonne_+1]);
           	griglia[indice].Registra(griglia[indice+colonne_]);      
           	if (!primo)
             	griglia[indice].Registra(griglia[indice+colonne_-1]);
        	}	 
        } 
    }
 
    inline const int Righe() const { return righe_; }
    inline const int Colonne() const { return colonne_; }
}; 
 
//Stampa a schermo la griglia. Gestione !statica! delle dimensioni. Per variare, utilizzare griglia.Righe() e Colonne()
void Stampa( Griglia& g) {
    cout << "\n\n"; //ne abbiamo messi 2 per bellezza
    cout << "+--------------------+\n|";
    for (int indice=0;indice < 400;++indice){ //Caratteri.
     	bool ultimo = ( (indice%20) == 19);
     	g[indice].Leggi()?cout << "O":cout << " ";
     	if (ultimo){
       		if (indice !=399)
         	{cout << "|\n|";}
       		else
         	{cout << "|\n";}
     	}
    }
    cout << "+--------------------+\n"; 
 }
 
int main () {
    Griglia griglia(20,20); 
    griglia.Genera();
 
    // Inizializza la griglia casualmente, con fattore di 
    // riempimento un ottavo.
    // Gestione !statica! delle dimensioni. Per variare, utilizzare griglia.Righe() e Colonne()
    srand(time(0));
    for (int i=0; i < 100;++i){
     	griglia.Imposta((rand()>>4) %400);
    }
 
   	while (1){
     	Stampa(griglia);   
     	griglia.Cicla();   
     	griglia.Verifica();
     	// Aspetta la pressione di enter
     	cin.get(); //Comando che è stra utile poiché registra la pressione del tasto, e quindi è stra utile.
   }
   	// Mai raggiunto
   	return 0;
}