Bienvenido al foro.
En primer lugar, sería conveniente que editases el mensaje y decorases el código con las etiquetas GeSHi para mejorar su legibilidad.
Dicho esto, vamos a intentar resolver tu duda.
Vamos a simplificar el entorno. Imagina que tenemos esta clase:
class POO
{
public:
int dato( );
static POO* MetodoEstatico( );
};
con esta clase tu podrías tener un código tal que:
std::cout << POO::MetodoEstatico( )->dato( );
Y la pregunta es ¿Por qué? ¿Cómo funciona? Muy sencillo.
Si te fijas, el método estático devuelve un puntero a una clase de tipo POO, lo que estás haciendo es recuperar ese puntero y acceder a los miembros de la instancia apuntada por dicho puntero. El código que te he puesto antes se puede descomponer para facilitar su lectura
POO* puntero = POO::MetodoEstatico( );
std::cout << puntero->dato( );
Este tipo de estructura se usa mucho al programar Singleton, que sirve para asegurarse de que sólo existe una instancia de una clase concreta... una forma de implementar un sigleton es la siguiente:
class Singleton
{
public:
int dato( )
{ return _dato; }
static Singleton* Instance( )
{
static Singleton* instance = new Singleton( );
return instance;
}
private:
// Los constructores son privados para impedir que se creen nuevas instancias
Singleton( )
{ _dato = 1; }
// El constructor copia no hace falta implementarlo, con declararlo como privado vale
Singleton( const Singleton& );
// Al operador de asignación le pasa lo mismo, no hace falta implementarlo.
Singleton& operator=( const Singleton& );
};
Obviamente, desde un método estático no se pueden llamar a miembros no estáticos de la clase, el siguiente código no compila:
class POO
{
public:
int dato( )
{ return _dato; }
static int MetodoEstatico( )
{ return dato( ); }
};
No se si con esto he resuelto tu duda, espero que sí.
Un saludo.
Mostrar Mensajes
