C++再论单例模式

#include <iostream>
#include <windows.h>
#include <mutex>
std::mutex gmutex;
using namespace std;

template<typename Type>
class Singleton
{
public:
static Type* GetSingleton()
{
if (siglen == NULL)
{
unique_lock<std::mutex> lock(gmutex);//C++11加锁。
if (siglen == NULL)
{
siglen = new Type();
Type *temp = new Type();
MemoryBarrier();
siglen = temp;
}
}
return siglen;
}
private:
static Type* siglen;
};

template<typename Type>
Type* Singleton<Type>::siglen = NULL;

class Text
{
public:
Text()
{
data = 100;
//因为是单例模式，所以唯一会出现申请内存，调用构造
//函数，赋值三个步骤混乱的机会只有在前面的1-2次
//的时候，可惜速度太快了，这种情况发生的概率及其低
//，但是我们的心理要始终明白。
}
void Printf()
{
cout << "data="<<data << endl;
}
static DWORD WINAPI ThreadFunc(LPVOID arg)
{
Singleton<Text>::GetSingleton()->Printf();
return DWORD(0);
}
private:
int data;
};

int main()
{
HANDLE hThread;
DWORD threadId;

for (int i = 0; i < 10; i++)
{
hThread = CreateThread(NULL, 0, &(Text::ThreadFunc), (void *)"123",0, &threadId);
}
Sleep(5);
cout << "ThreadFunc is running!!!" << endl;
return 0;
}

#include <iostream>
using namespace std;
//引用计数的智能指针。
template<typename Type>
class my_auto_ptr
{
public:
my_auto_ptr(Type* p = NULL) :ptr(p)
{
count = new int[1];
count[0] = 1;
}
my_auto_ptr(const my_auto_ptr &ma)
{
count = ma.count;
count[0]++;
}
my_auto_ptr& operator=(const my_auto_ptr &ma)
{
if (this != &ma)
{
this->~my_auto_ptr();
count = ma.count;
count[0]++;
ptr = ma.ptr;
}
return *this;
}
~my_auto_ptr()
{
if (count!=NULL &&count[0]-- == 1)
{
cout << "~my_auto_ptr()" << endl;
delete ptr;
ptr = NULL;
delete[] count;
count = NULL;
}
}
Type* operator->()
{
return ptr;
}
Type& operator*()
{
return *ptr;
}
private:
Type *ptr;
int *count;
};
int main()
{
my_auto_ptr<int> ps(new int(100));
my_auto_ptr<int> pb(ps);
my_auto_ptr<int> pd;
pd = pb;
return 0;
}