/*
class A
{};
A a;
单例模式就是全局只有一个类A产
生的对象不允许产生多个对象。
1.static成员变量实现了同类对象间信息共享
2.static成员类外存储,求类大小,并不包含在内
3.static成员是命名空间属于累的全局变量,存储在data区
4.static成员只能类外初始化
5.可以通过类名访问(无对象生成时亦可),也可以通过对象访问
*/
# include <iostream>
using namespace std;
class A
{
private:
A()
{
a = new A;
}
public:
static A* getInstace()
{
return a;
}
private:
static A* a;
};
A* A::a = NULL;
//实现单例步骤
//1.构造函数私有化
//2.增加静态类私有的当前类的指针变量
//3.提供静态对外接口,可以让用户获得单例对象
//单例 分为懒汉式 饿汉式
/*
饿汉式的特点是一开始就加载了,如果说懒汉
式是“时间换空间”,那么饿汉式就是“空间换
时间”,因为一开始就创建了实例,所以每次
用到的之后直接返回就好了
*/
//懒汉式
class Singleton_lazy
{
private:
Singleton_lazy()
{
cout << "我是懒汉式构造" << endl;
}
public:
static Singleton_lazy* getInstance()
{
if(pSingleton == NULL)
{
pSingleton = new Singleton_lazy;
}
return pSingleton;
}
# if 0
//推荐不要增加这个功能,因为是单例模式如果释放了
//就没了,全局就这一个变量。
static void freeSpace()
{
if(pSingleton != NULL)
{
delete pSingleton;
}
}
# endif
private:
static Singleton_lazy* pSingleton;
};
//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;
//饿汉式
class Singleton_hungry
{
private:
Singleton_hungry()
{
cout << "我是饿汉构造" << endl;
}
public:
static Singleton_hungry* getInstance()
{
return pSingleton;
}
# if 0
//推荐不要增加这个功能,因为是单例模式如果释放了
//就没了,全局就这一个变量。
static void freeSpace()
{
if(pSingleton != NULL)
{
delete pSingleton;
}
}
# endif
//嵌套类
class Garbo
{
public:
Garbo()
{
cout << "Garbo()" << endl;
}
~Garbo()
{
cout << "~Garbo" << endl;
if(pSingleton != NULL)
{
delete pSingleton;
}
}
};
private:
static Singleton_hungry* pSingleton;
static Garbo garbo;
};
//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;
//注意要这样写
Singleton_hungry::Garbo Singleton_hungry::garbo = Garbo();
void test01()
{
Singleton_lazy* p1 = Singleton_lazy::getInstance();
Singleton_lazy* p2 = Singleton_lazy::getInstance();
if(p1 == p2)
{
cout << "俩个指针指向同一快内存空间,是单例" << endl;
}
else
{
cout << "不是单例模式" << endl;
}
Singleton_hungry* p3 = Singleton_hungry::getInstance();
Singleton_hungry* p4 = Singleton_hungry::getInstance();
if(p3 == p4)
{
cout << "俩个指针指向同一快内存空间,是单例" << endl;
}
else
{
cout << "不是单例模式" << endl;
}
}
//单例对象释放问题
void test02()
{
// Singleton_hungry::freeSpace();
}
int main(int argc, char *argv[])
{
cout << "main函数开始执行" << endl;
test01();
return 0;
}
class A
{};
A a;
单例模式就是全局只有一个类A产
生的对象不允许产生多个对象。
1.static成员变量实现了同类对象间信息共享
2.static成员类外存储,求类大小,并不包含在内
3.static成员是命名空间属于累的全局变量,存储在data区
4.static成员只能类外初始化
5.可以通过类名访问(无对象生成时亦可),也可以通过对象访问
*/
# include <iostream>
using namespace std;
class A
{
private:
A()
{
a = new A;
}
public:
static A* getInstace()
{
return a;
}
private:
static A* a;
};
A* A::a = NULL;
//实现单例步骤
//1.构造函数私有化
//2.增加静态类私有的当前类的指针变量
//3.提供静态对外接口,可以让用户获得单例对象
//单例 分为懒汉式 饿汉式
/*
饿汉式的特点是一开始就加载了,如果说懒汉
式是“时间换空间”,那么饿汉式就是“空间换
时间”,因为一开始就创建了实例,所以每次
用到的之后直接返回就好了
*/
//懒汉式
class Singleton_lazy
{
private:
Singleton_lazy()
{
cout << "我是懒汉式构造" << endl;
}
public:
static Singleton_lazy* getInstance()
{
if(pSingleton == NULL)
{
pSingleton = new Singleton_lazy;
}
return pSingleton;
}
# if 0
//推荐不要增加这个功能,因为是单例模式如果释放了
//就没了,全局就这一个变量。
static void freeSpace()
{
if(pSingleton != NULL)
{
delete pSingleton;
}
}
# endif
private:
static Singleton_lazy* pSingleton;
};
//类外初始化
Singleton_lazy* Singleton_lazy::pSingleton = NULL;
//饿汉式
class Singleton_hungry
{
private:
Singleton_hungry()
{
cout << "我是饿汉构造" << endl;
}
public:
static Singleton_hungry* getInstance()
{
return pSingleton;
}
# if 0
//推荐不要增加这个功能,因为是单例模式如果释放了
//就没了,全局就这一个变量。
static void freeSpace()
{
if(pSingleton != NULL)
{
delete pSingleton;
}
}
# endif
//嵌套类
class Garbo
{
public:
Garbo()
{
cout << "Garbo()" << endl;
}
~Garbo()
{
cout << "~Garbo" << endl;
if(pSingleton != NULL)
{
delete pSingleton;
}
}
};
private:
static Singleton_hungry* pSingleton;
static Garbo garbo;
};
//类外初始化
Singleton_hungry* Singleton_hungry::pSingleton = new Singleton_hungry;
//注意要这样写
Singleton_hungry::Garbo Singleton_hungry::garbo = Garbo();
void test01()
{
Singleton_lazy* p1 = Singleton_lazy::getInstance();
Singleton_lazy* p2 = Singleton_lazy::getInstance();
if(p1 == p2)
{
cout << "俩个指针指向同一快内存空间,是单例" << endl;
}
else
{
cout << "不是单例模式" << endl;
}
Singleton_hungry* p3 = Singleton_hungry::getInstance();
Singleton_hungry* p4 = Singleton_hungry::getInstance();
if(p3 == p4)
{
cout << "俩个指针指向同一快内存空间,是单例" << endl;
}
else
{
cout << "不是单例模式" << endl;
}
}
//单例对象释放问题
void test02()
{
// Singleton_hungry::freeSpace();
}
int main(int argc, char *argv[])
{
cout << "main函数开始执行" << endl;
test01();
return 0;
}