C++单例模式

#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