como excluir object singleton

Assumindo essa implementação de um padrão singleton (é claro que devemos evitar Singleton: é apenas uma questão), acabei de pensar em objects estáticos sendo criados. Ele é criado na pilha por um new operador, claro, mas como isso é destruído? No exemplo a seguir, temos um vazamento, então como se deve implementar a exclusão do object singleton estático ? Deve haver uma interface pública please_delete() adotada, então pode-se chamar myC->please_delete() ou existe outra maneira de conseguir isso?

 class CC{ public: static CC* cObj(){ if(c_ptr==NULL){ c_ptr=new CC(); return c_ptr; }else return c_ptr; } int getValue(){return value_;} void setValue(int val){value_=val;} ~CC(){cout<<"~CC";} private: CC():value_(12345){cout<<"CC";} static CC* c_ptr; int value_; }; // Allocating and initializing CC's // static data member. The pointer is being // allocated - not the object itself. CC *CC::c_ptr = 0; int main(){ //Singleton pattern CC* myC = CC::cObj(); cout<getValue(); return 0; } 

saída: CC12345

FUNCIONAR BEM SUCEDIDO (tempo total: 67ms)

Notei que, de fato, podemos sempre declarar instância estática singleton dentro de shared_ptr como com boost::shared_ptr bCptr(CC::cObj()); mas o padrão Singleton não menciona o problema da exclusão do object, então talvez exista alguma outra abordagem?

Parte do padrão de design do Singleton é que ele é indestrutível.

EDITAR:

Existem duas variedades de singletons com relação à destrutibilidade:

  1. Destrutível (eles morrem quando o aplicativo faz)
  2. Indestrutível (eles morrem quando a máquina faz)

De qualquer maneira, se construído corretamente, uma vez que a instância singleton é criada, ela permanece. Esta é uma das principais críticas ao padrão de design Singleton.

Aqui estão algumas referências que abordam o aspecto de destrutibilidade do padrão.

http://nicolabonelli.wordpress.com/2009/06/04/singleton-a-mirage-of-perfection/ http://www10.informatik.uni-erlangen.de/Teaching/Courses/SS2009/CPP/altmann. pdf http://sourcemaking.com/design_patterns/singleton http://sourcemaking.com/design_patterns/to_kill_a_singleton

O padrão singleton clássico não descreve o aspecto da deleção.

No entanto, se eu tiver que fazer isso, eu começaria com uma abordagem simples como a seguinte (não é à prova de erros):

1) Semelhante ao método estático para criar / recuperar o object singleton, digamos createObject() , existe um método estático para destruir o object singleton, digamos destructObject()

2) Existe um contador que conta o número atual de objects no sistema;

  • começa em 0
  • na chamada createObject() , incrementa em 1
  • na chamada deleteObject() , decrementa em 1.
    • Se atingir 0, a delete será chamada para realmente destruir o object

Eu prefiro não usar um ponteiro.

 class Single { private: Single(); public: Single& Instance() { static Single the_instance; Return the_instance; } }; 

Esse singleton viverá a partir do momento em que Instance() é chamado até que o aplicativo esteja saindo e executando a destruição de objects estáticos. Neste caso, o destruidor do object singleton será chamado.

Na prática, mesmo ao usar um ponteiro como no exemplo original, a memory será recuperada pelo SO após a saída do aplicativo. No entanto, neste caso, o destruidor do object não será chamado.