Entendiendo el patrón Singleton.

[dehm]

Bueno, pues aquí va una implementación mejor (casi nada es mío):

Código C++:

#ifndef SINGLETON_H
#define SINGLETON_H
 
 
class Singleton
{
    public:
        Singleton (const Singleton&) = delete;
        Singleton& operator=(const Singleton&) = delete;
        static Singleton& getInstance();
        int VerValor();
        void duplicar();
        ~Singleton();
 
    private:
        Singleton();
        static Singleton* instancia;
        int valor;
 
};
 
#endif // SINGLETON_H
 

Código C++:

#include "Singleton.h"
#include <iostream>
 
Singleton::Singleton():valor(5){}
 
Singleton::~Singleton()
{
    std::cout<<"Borrando....";
}
 
Singleton& Singleton::getInstance()
{
     static Singleton instancia;
     return instancia;
}
 
int Singleton::VerValor()
{
    return valor;
}
 
void Singleton::duplicar()
{
    valor*=2;
}
 

Código C++:

#include <iostream>
#include "Singleton.h"
 
using namespace std;
 
int main()
{
    Singleton& S = Singleton::getInstance();
    Singleton& S2 = Singleton::getInstance();
    S.duplicar();
    cout<<S2.VerValor()<<endl;
    return 0;
 
}
 

Por comentar las observaciones que he hecho....
Al principio no había hecho el uso de "delete" en los constructores de copia y asignación y he creado la instancia al modo "clásico"

Código C++:

Singleton S3(Singleton::getInstance());
 

Pero al ver el destructor me sonaba raro que se invocase 2 veces al mismo.
Luego he visto que lo suyo es prohibir estos constructores. A cambio, me obliga a crear la instancia como referencias.

Ahora, por la forma de ser creada la instancia, entiendo que no tiene sentido que se le pongan parámetros.

Lo que no entiendo muy bien es el por qué de este patrón. Es decir, en cierto modo estoy "enmascarando" que me remito siempre al mismo objeto, pero ese comportamiento lo puedo hacer igual con punteros, entiendo yo.