Типизированный синглтон расширение, потенциальные проблемы??? Опции

[ViGOur]

Подумалось мне тут, что если взять типизированный синглтон:

template <class T>
class CTypedSingleton;

который создает-возвращает указатель на класс типа T, то при вызове:

delete p; // указатель на класс типа T

вызываться декремент счетчика ссылок у нас не будет и его нужно вызывать в ручную, что чревато ошибками!
Следовательно нужно создать некий класс обертку, который открыто унаследован от класса T и закрыто от нашего типизированного синглтона, а в нем уже переопределить operator delete, в котором собственно и вызывать наш CTypedSingleton<T>::free();

Что я и сделал в коде ниже:

собственно сам код

#include <iostream>

class CClass
{
public:
    virtual ~CClass(){  }
};

template <class T>
class CTypedSingleton;

template<class T>
class CTypedWrapper : public T, private CTypedSingleton<T>
{
public:
    void operator delete(void *p)
    {
        std::cout << "CTypedWrapper::operator delete" << std::endl;
        CTypedSingleton<T>::free();
    }
};

template <class T>
class CTypedSingleton
{
    static T* m_self;
    static int m_refcount;

protected:
    CTypedSingleton(){}
    CTypedSingleton(const CTypedSingleton&){}
    virtual ~CTypedSingleton(){ m_self = 0; }
    CTypedSingleton &operator=(const CTypedSingleton&){}

public:
  static T *init()
  {
      std::cout << "init" << std::endl;
      if(!m_self)
          m_self = new CTypedWrapper<T>;
      m_refcount++;
      return m_self;
  }

  static void free()
  {
      std::cout << "free" << std::endl;
      if( m_refcount > 0)
      {
          --m_refcount;
          if( m_refcount == 0)
          {
              delete m_self;
              m_self = 0;
          }
      }
  }
};

template <class T>
T *CTypedSingleton<T>::m_self = 0;

template <class T>
int CTypedSingleton<T>::m_refcount = 0;

int main(int , char **)
{
    CClass *p = CTypedSingleton<CClass>::init();
    delete p;

    return 0;
}

В принципе потенциальных проблем я не виже, но может это из-за того, что я пока грипую и возможно не так внимателен...
Что вы скажите?

[AD]

Слушай, а почему нельзя пользоваться обычным Singleton??? Ну вот такого рода:

template <class T>
class Singleton
{
protected:
    Singleton() {}
    virtual ~Singleton() {}
public:
    static T* instance()
    {
        static T self;
        return &self;
    }
};

Чем этот синглетон будет плох? Почему его не использовать

Пример использования такой, к примеру:

class ZLogger: public Singleton<ZLogger>
{
/// anything
};

[ViGOur]

А если объектов будет много, они тяжеловесны и не все всегда нужны?

[AD]

А если объектов будет много, они тяжеловесны и не все всегда нужны?

Ну так понятнее объяснил. Да.

Сообщение отредактировал AD - 26.2.2013, 15:56

[lanz]

Может тогда вообще не стоит делать их синглтонами?

[ViGOur]

А тогда как за нимим следить проще чтобы не плодить?

[Алексей1153]

ViGOur, конструктор и виртуальный деструктор рулят Счётчик - (опять это слово ) инкапсулированный статический синглтон класса

[Iron Bug]

тема синглтона, на самом деле, не такая простая, как кажется. это уже тут обсуждалось:
http://www.forum.crossplatform.ru/index.php?showtopic=8976
если делать всё по-честному, там нужны двойные локи. можно сделать ну очень красивый синглтон с типами, в С++11. но это не поддерживает msvc, например.

[ViGOur]

Алексей1153, читай внимательней...

Iron Bug, согласен синхронизация всегда нужна. В примере я все упростил, чтобы было понятней...
Сейчас почитаю.

[Алексей1153]

который создает-возвращает указатель на класс типа T, то при вызове:
delete p; // указатель на класс типа T
вызываться декремент счетчика ссылок у нас не будет и его нужно вызывать в ручную, что чревато ошибками!

что тут читать внимательнее то: при вызове delete вызовется деструктор (в случае виртуального - начиная с детей, заканчивая родителем). В родительском классе уменьшаем счётчик.

Ну а то, что ты предпочёл шаблон там, где нужно было применить виртуальное наследование - это кто ж виноват