[SOLUCIONADO] Entendiendo el patrón Singleton.

[dehm]

Hola:

Ahora que tengo algo de tiempo, he retomado el C++ y en este caso iba a ver si profundizo en el tema de patrones. Para ello he empezado con el que se supone que es el más sencillo, el Singleton.

La implementación está casi fusilada de uno de los muchos ejemplos que hay en la red, pero cuando he querido hacer mis enredos han sido todo problemas.

Esta es la implementación:

Singleton.h

Código C++:

#ifndef SINGLETON_H
#define SINGLETON_H
 
 
class Singleton
{
    public:
        static Singleton* getInstance();
        virtual ~Singleton();
        int VerValor();
        void duplicar();
 
    protected:
        Singleton();
 
    private:
        static Singleton* instancia;
        int valor;
 
};
 
#endif // SINGLETON_H
 

Singleton cpp

Código C++:

#include "Singleton.h"
#include <iostream>
 
Singleton*::Singleton::instancia=nullptr;
 
Singleton::Singleton():valor(5){}
 
Singleton::~Singleton()
{
    std::cout<<"Borrando....";
    delete instancia;
}
 
Singleton*::Singleton::getInstance()
{
     if(instancia == nullptr)
     {
         instancia = new Singleton();
         //valor=v;
     }
  return instancia;
}
 
int Singleton::VerValor()
{
    return valor;
}
 
void Singleton::duplicar()
{
    valor*=2;
}
 

main.cpp

Código C++:

#include <iostream>
#include "Singleton.h"
 
using namespace std;
 
int main()
{
    Singleton* S;
    S->getInstance();
    cout<<S->VerValor();
    delete S;
    return 0;
 
}
 

Y las dudas son:

Si llamo a la función VerValor() obtengo error de segmentación, pero no entiendo el por qué.
Se supone que en la creación de la instancia, le doy un valor al miembro "valor". No sé por qué me da error al retornarlo,
Y cuando borro el puntero, no se me muestra el mensaje del destructor. ¿Y eso por que?

Y otra cosa:

Si quiero crear la instancia de la clase con algún argumento (no sé si se dará el caso en alguna aplicación práctica, pero bueno, por probar) lo intento así:

Código C++:

Singleton*::Singleton::getInstance(int v)
{
     if(instancia == nullptr)
     {
         instancia = new Singleton();
         valor=v;
     }
  return instancia;
}
 

Pero me da el error:
include/Singleton.h|18|error: invalid use of member ‘Singleton::valor’ in static member function|

Gracias como siempre

[eferion]

Te contestó desde el móvil, así que disculpas si no queda del todo organizado.

Para empezar un singleton NO DEBE BORRARSE, ya que el puntero "instance" no se entera y se queda apuntando a una dirección no válida. Para evitar ese tipo de tentaciones lo mejor es devolver una referencia, ya que a nadie se le ocurre convertir una referencia en puntero para borrarla.

En segundo lugar, queda más limpio si evitas usar una variable estática a nivel de clase, es mejor declararla estática a nivel de función:

Código C++:

clases Singleton
{
public:
  static Singleton& Instance()
  {
    static Singleton instance;
    return instance;
  }
};
 

Además, lo suyo es declarar los constructores privados, para evitar que se hagan copias no autorizadas del objeto. No sólo el constructor por defecto, sino también el constructor copia y, por costumbre, el operador de asignación.

La excepción te salta porque getInstance es un método estático... Es decir, hay que llamarlo S=Singleton::getInstance(). Además que S es un puntero no inicializado... cualquier uso de ese puntero te dará error.

Y para terminar, Singleton se usa cuando se necesita una única instancia del objeto y que este sea global a toda la aplicación. No veo por qué querrías crear un objeto con argumentos... Y si después pides otro con argumentos diferentes?? En esos casos no necesitas un Singleton sino objetos comunes.

Un saludo

[dehm]

Iniciado por eferion

Te contestó desde el móvil, así que disculpas si no queda del todo organizado.

Para empezar un singleton NO DEBE BORRARSE, ya que el puntero "instance" no se entera y se queda apuntando a una dirección no válida. Para evitar ese tipo de tentaciones lo mejor es devolver una referencia, ya que a nadie se le ocurre convertir una referencia en puntero para borrarla.

En segundo lugar, queda más limpio si evitas usar una variable estática a nivel de clase, es mejor declararla estática a nivel de función:

Código C++:

clases Singleton
{
public:
  static Singleton& Instance()
  {
    static Singleton instance;
    return instance;
  }
};
 

Además, lo suyo es declarar los constructores privados, para evitar que se hagan copias no autorizadas del objeto. No sólo el constructor por defecto, sino también el constructor copia y, por costumbre, el operador de asignación.

La excepción te salta porque getInstance es un método estático... Es decir, hay que llamarlo S=Singleton::getInstance(). Además que S es un puntero no inicializado... cualquier uso de ese puntero te dará error.

Y para terminar, Singleton se usa cuando se necesita una única instancia del objeto y que este sea global a toda la aplicación. No veo por qué querrías crear un objeto con argumentos... Y si después pides otro con argumentos diferentes?? En esos casos no necesitas un Singleton sino objetos comunes.

Un saludo

Gracias como siempre, eferion. Ya tengo base para seguir investigando.

[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.

[eferion]

Iniciado por dehm

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.

Esa línea, como comentas está mal. Como bien as notado, el patrón singleton pretende que únicamente haya una instancia del objeto para toda la aplicación y ahí estás intentando obtener una copia del objeto... lo cual lleva inevitablemente a que exista mas de un objeto.

Puede sonar un poco raro usar una variable como referencia, pero se pueden optimizar bastantes partes del código con esa tontería de las referencias. Hay que recordar que usar una referencia implica que no se llama al constructor copia del objeto...

La forma correcta de llamar a getInstance sería la siguiente:

Código C++:

Singleton& S3 = Singleton::getInstance();
 

Iniciado por dehm

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

Esa es una buena noticia, quiere decir que te van quedando claros los detalles del patrón :)

Iniciado por dehm

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.

La principal ventaja de este patrón con respecto al uso de punteros es que no tienes que arrastrar los punteros por todo tu código. Imagínate que en un proyecto tienes que arrastrar 5 punteros por todas tus funciones porque no te dejan usar este patrón... tus funciones tendrían los parámetros necesarios para funcionar y un plus de 5 parámetros para arrastrar los punteros.

Como contrapartida, con este patrón se pierde un poco el hilo de la ejecución. El acceso al Singleton es libre y queda en manos del desarrollador el hacer un uso responsable del mismo... si en vez del singleton arrastras el puntero es muy sencillo prohibir el acceso al mismo simplemente no proporcionándolo.

A mi personalmente no me gusta demasiado tener que depender de este patrón, si hay razones de peso suficientes vale, pero con cautela. Es muy facil caer en la tentación y convertir toda la aplicación en una sucesión de singleton...

Un saludo.

[dehm]

Muchas gracias eferion. ¿Qué haríamos sin ti en el foro?

Bueno, marco como solucionado y cuando haga alguna prueba más con este me pondré con otro patrón.

¡Saludos!