#include <iostream>
#include <string>
using namespace std;
class SignalExample
{
static SignalExample* c_instance;
//将所有的构造函数(构造函数、拷贝构造、赋值重载)都私有化,使外部不能直接创建对象
SignalExample()
{
}
SignalExample();
SignalExample(const SignalExample&);
SignalExample& operator = (const SignalExample&);
//创建一个静态的私有化成员,用来存储唯一的一个单例对象
public:
//静态函数 用于创建唯一的单例对象 必须是公有的静态的,这样在未创建对象之前就可以直接调用
static SignalExample* GetInstance();
void print();//用于打印对象地址的检测函数
};
SignalExample* SignalExample::c_instance = NULL;
SignalExample* SignalExample::GetInstance()
{
//如果已经创建了一个对象,那么直接返回,如果没有则调用构造函数
if (c_instance == NULL)
{
c_instance = new SignalExample();
}
return c_instance;
}
void SignalExample::print()
{
cout<<"address-->this:"<<this<<endl;
}
int main()
{
SignalExample* s = SignalExample::GetInstance();
SignalExample* s1 = SignalExample::GetInstance();
SignalExample* s2 = SignalExample::GetInstance();
s->print();
s1->print();
s2->print();
return 0;
}
#include <iostream>
#include <string>
#include "Singleton.h"
using namespace std;
class SignalExample
{
friend class Singleton<SignalExample>;
//将所有的构造函数(构造函数、拷贝构造、赋值重载)都私有化,使外部不能直接创建对象
SignalExample()
{
}
SignalExample(const SignalExample&);
SignalExample& operator = (const SignalExample&);
//创建一个静态的私有化成员,用来存储唯一的一个单例对象
public:
void print();//用于打印对象地址的检测函数
};
class Test
{
private:
friend class Singleton<Test>;
Test()
{
}
Test(const Test&)
{
}
Test& operator = (const Test&);
public:
void print();//用于打印对象地址的检测函数
};
void Test::print()
{
cout<<"address-->this:"<<this<<endl;
}
void SignalExample::print()
{
cout<<"address-->this:"<<this<<endl;
}
int main()
{
SignalExample* s = Singleton<SignalExample>::GetInstance();
SignalExample* s1 = Singleton<SignalExample>::GetInstance();
SignalExample* s2 = Singleton<SignalExample>::GetInstance();
Test* s4 = Singleton<Test>::GetInstance();
Test* s3 = Singleton<Test>::GetInstance();
s->print();
s1->print();
s2->print();
s3->print();
s4->print();
return 0;
}
#ifndef _SINGLETON_H_
#define _SINGLETON_H_
template
< typename T >
class Singleton
{
static T* c_instance;
public:
static T* GetInstance();
};
template
< typename T >
T* Singleton<T>::c_instance = NULL;
template
< typename T >
T* Singleton<T>::GetInstance()
{
if(c_instance == NULL)
{
c_instance = new T();
}
return c_instance;
}
#endif