Que tal,
¿Que desventajas podria haber al utilizar el operador -> para referenciar la instancia de un singleton?
Conocí este "truco" por zupervaca hace unos años, pero en realidad me siempre me quedaron dudas y nunca lo usé.
Pego su propio codigo:/// <summary>Template que nos permite acceder a una clase unica</summary>
template <class TYPE> class Singleton
{
// Metodos
public:
/// <summary>Operador -></summary>
TYPE *operator -> ()
{
return this->Instance();
}
/// <summary>Operador *</summary>
TYPE *operator * ()
{
return this->Instance();
}
// Valores privados
private:
/// <summary>Obtener la instancia unica</summary>
TYPE *Instance()
{
static TYPE intance;
return &intance;
}
};
Obviamente los singletones tendrián una nomenglatura especial para evitar confusiones.
Algo como un prefijo, posiblemente "S_"
Comparando:System::instance()->OpenFile("");
System::get_instance()->OpenFile("");
S_System->Open_File("");
En facilidad de lectura y escritura gana el "S_->", se pierde el respeto al singleton pero en realidad no creo que se puedan introducir muchos bugs por eso ...
Gurus de C++ ... que opinion tienen al respecto?
Yo personalmente prefiero la primera o segunda forma. Me parece mucho más clara que sobrecargar el operador -> y puede llevar a confusión al que lo lea.
Es mi opinión.. yo en general no uso sobrecargas en mis clases a excepción de algun tipo abstracto de dato(vector, cadena, etc).
Cita de: "ZaelSiuS"Es mi opinión.. yo en general no uso sobrecargas en mis clases a excepción de algun tipo abstracto de dato(vector, cadena, etc).
Esto lo he escuchado antes y suma al tema de "no hacerlo por que no se acostumbra por convencion", pero estaria dispuesto a romper esa convención si me sirviera en hacer mas sencilla la escritura y lectura.
Algo mas?
Mas especialmente por problemas que pueda traer el operador en si, problemas de funcionalidad.
Estoy deacuerdo con Zaelsius.
A las convenciones no se llega porque si, y si lo que buscas es hacer mas clara la lectura en mi opinion no lo consigues. Cualquiera que se una al proyecto (o si lo poneis open source y quiere mejorarlo) y vea las dos primeras lineas sabra de inmediato que es un singleton. Sin embargo con la tercera, a priori pensara que es un objecto, buscara que tipo de objeto es y no lo encontrara, hasta que se de cuenta de que se ha sobreescrito el operador.
Yo desde luego no aconsejo hacerlo asi. Suerte de todos modos ;)
Respecto a la conveniencia de la sobrecarga de operadores en general, es una cuestión algo "religiosa" y que no tiene una única respuesta válida. ¿Realmente les facilita el trabajo a todos los miembros del equipo? ¿O en cambio les confunde más? Personalmente, creo que es adecuado aplicar el principio de menor sorpresa a la hora de tomar este tipo de decisiones.
Dicho sea de paso, aunque no es el tema del hilo, los singletones dan pie a la introducción de tantos problemas que es una buena práctica evitar a toda costa diseños que contemplen el uso (y en la mayoría de ocasiones, abuso) de este antipatrón.