class Singleton {
protected:
static Singleton* _self;
static int _refcount;
Singleton(){}
virtual ~Singleton() {printf ("~Singletonn");}
public:
static Singleton* Instance();
void FreeInst();
};
class SinglImpl: public Singleton {
protected:
SinglImpl(){}
//объявление виртуальным в базовом классе автоматически
//дает виртуальность в производном.
~SinglImpl() {printf ("~SinglImpln");}
public:
static Singleton* Instance() {
if(!_self) _self = new SinglImpl();
_refcount++;
return _self;
}
};
void main() {
Singleton *p = SinglImpl::Instance();
…
…
…
p->FreeInst();
}
Результат работы:
~SinglImpl
~Singleton
Иногда может возникнуть ситуация, при которой клиент должен полиморфно работать с объектами, имеющими общий базовый класс, но некоторые из них реализуют паттерн Singleton, а некоторые нет. Проблема возникает в момент освобождения объектов, так как у простых классов нет механизма отслеживания ссылок, а у классов, реализующих Singleton, он есть. При вызове метода FreeInst() через указатель на базовый класс будет вызываться FreeInst() базового класса, не имеющего понятия о подсчете ссылок. Это приведет и к безусловному удалению объектов “Singleton” из памяти. Для предотвращения такого поведения следует объявить виртуальным метод FreeInst() в базовом классе и реализовать специфическое поведение метода для классов Singleton. Реализация FreeInst() в базовом классе предоставляет механизм удаления объектов, не являющихся Singleton’ами.
Листинг 8
class base {
protected:
virtual ~base(){} //гарантируем удаление только через FreeInst()
public:
virtual void Do1()=0;
virtual void FreeInst(){delete this;}
};
class Simple: public base {
protected:
~Simple () {printf("Simple::~Simplen");}
public:
void Do1(){printf("Simple::Do1n");}
};
class Singleton: public base {
static Singleton* _self;
static int _refcount;
protected:
Singleton(){}
~Singleton () {printf("Singleton::~Singletonn");}
public:
static Singleton* Instance() {
if(!_self) _self = new Singleton ();
_refcount++;
return _self;
}
void FreeInst() {_refcount--; if(!_refcount) {delete this; _self=NULL;}}
void Do1(){printf("Singleton::Do1n");}
};
Singleton* Singleton::_self=NULL;
int Singleton:: _refcount=0;
class Client {
base *objs[2];
int ind;
public:
Client(){ objs[0]=NULL;objs[1]=NULL;ind=0; }
~Client() {
for(int i=0;i<ind;i++) objs[i]->FreeInst();
}
void Add(base *p){if(ind<2) objs[ind++]=p;}
void Do() {
for(int i=0;i<ind;i++) objs[i]->Do1();
}
};
void main() {
Client cl;
cl.Add(Singleton::Instance());
cl.Add(new Simple());
cl.Do();
}
результат работы программы:
Singleton::Do1 Simple::Do1 Singleton::~Singleton Simple::~Simple
В данном примере при разрушении объект класса Client автоматически вызываются методы FreeInst() для каждого из хранимых указателей. Благодаря тому, что этот метод объявлен виртуальным, а в классах реализующих паттерн Singleton этот метод переопределен с учетом подсчета ссылок, то программа работает именно так как ожидается.
Применение шаблонов языка C++.
Альтернативой приведенной выше реализации может служить реализация класса Singleton при помощи шаблонов языка С++. Преимущество такого подхода заключается в автоматической параметризации метода Instance(), что приводит к отсутствию необходимости переопределять его в классах потомках. По изложенным ранее причинам конструктор класса-потомка также должен быть объявлен защищенным, а деструктор виртуальным. Кроме того, базовый класс Singleton должен быть объявлен другом класса наследника, поскольку метод Instance() базового класса в этой модели создает объект производного класса.
листинг 9
template <class T>
class Singleton {
static T* _self;
static int _refcount;
protected:
Singleton(){}
virtual ~Singleton(){_self=NULL;}
public:
static T* Instance();
void FreeInst();
};
template <class T>
T* Singleton<T>::_self = NULL;
template <class T>
int Singleton<T>::_refcount=0;
template <class T>
T* Singleton<T>::Instance() {
if(!_self) _self=new T;
_refcount++;
return _self;
}
template <class T>
void Singleton<T>::FreeInst() {
if(--_refcount==0) delete this;
}
class Derived: public Singleton<Derived> {
protected:
Derived(){}
friend class Singleton<Derived>;
};
int main(int argc, char* argv[]) {
Derived *p = Derived::Instance();
…
…
…
p->FreeInst();
return 0;
}
Классы, объекты которых должны существовать в единственном экземпляре, просто наследуются от шаблонного класса Singleton. Такой подход, однако, не позволяет создать иерархию классов во главе с классом-интерфейсом, в которой некоторые из классов-наследников реализуют паттерн проектирования Singleton, а некоторые нет (См листинг 8). С другой стороны, применение параметризованного класса позволяет вынести код Singleton’а в отдельный файл и включать его в последствии в создаваемые приложения, обеспечивая тем самым повторное использование паттерна Singleton.
Резюме
1. В классе Singleton конструктор должен быть объявлен в защищенной секции для предотвращения создания объекта способом, отличным от вызова метода Instance().
2. Деструктор также следует поместить в защищенную секцию класса, чтобы исключить возможность удаления объекта оператором delete.
3. Для автоматического подсчета ссылок при освобождении объекта следует применять специальный метод, такой как FreeInst().
4. При наследовании от класса, реализующего паттерн Singleton, конструктор класса-потомка также должен быть объявлен в защищенной секции. Деструктор должен быть объявлен как виртуальный. Класс-потомок должен переопределить метод Instance(), так, чтобы он создавал объект нужного типа.
5. Если предполагается полиморфная работа с классами, наследуемыми от одного базового класса, причем некоторые классы потомки реализуют паттерн Singleton, а некоторые нет, следует в базовом классе определить метод FreeInst() как виртуальный. Базовый класс предоставляет реализацию по умолчанию этого метода, просто вызывая оператор delete this. В классах-потомках, реализующих паттерн Singleton, при реализации метода FreeInst(), используйте механизм подсчета ссылок.
6. Если используется параметризированная версия Singleton, то в производных классах следует объявить базовый класс (Singleton) дружественным.
Литература
1. http://www.firststeps.ru/theory/c/r.php?29
2. http://ooad.asf.ru/patterns/patterninfo.asp?ID=13
3. Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес “Приемы объектно-ориентированного проектирования. Паттерны проектирования”
Комментарии:
Как бы так это заделать???
Во первых, статья очень хорошая и полезная, спасибо. Применил в реальной программе я этот сингелтон и остался очень доволен. Но мне надо было несколько изменить поведение исходного класса. У меня ситуация такая: есть клиент, который шлёт запросы на сервер, на сервере есть класс, который создаёт и хранит необходимые для обработки этих запросов таблицы. Но беда в том, что после обработки очередного запроса мне не надо уничтожать объект, т.к. эти запросы идут сериями по многу штук подряд, а удалять объект надо в конце серии... Я сделал во что:
template <class T>
T* Singleton<T>::Instance()
{
if(!_self)
{
_self=new T;
_refcount++; // вот это
}
_refcount++;
return _self;
}
Но выглядит на мой взгляд коряво. Может есть какие-то паттерны на этот случай?
Ну, в довесок хочу воткнуть так вот полу-смарт указатель:
template<class T>
class TSingeltonPtr
{
T *_t;
public:
TSingeltonPtr() { _t = T::Instance(); }
~TSingeltonPtr() { if(_t) _t->FreeInst(); }
operator T*() { return _t; }
T* operator->() { return _t; }
bool operator!() const { return _t==0; }
};
использование:
class Derived : public Singleton<Derived>
