饿汉式,基本版
#include <iostream>
using namespace std;
class Single {
private:
Single() {} // 构造函数私有
Single(const Single &) {}; // 拷贝构造函数私有
Single& operator=(const Single&) {}; // 赋值操作符私有,不允许复制操作
static Single _obj; // 一个属于类的对象
static int a; // 该对象的其他数据
public:
virtual ~Single() {}
static Single get_obj(){
return _obj;
}
static int get_data() {
return a;
}
static void set_data(int a2) {
a = a2;
}
};
Single Single::_obj;// 类static成员变量必须在类外初始化,否则会出现连接错误,可能是RAII
int Single::a = 1;// 为什么静态成员不能再类内初始化:因为静态成员属于整个类,而不属于某个对象,如果在类内初始化,会导致每个对象都包含该静态成员,这是矛盾的。
int main()
{
Single::get_obj().set_data(12);
cout << Single::get_obj().get_data() << endl;
return 0;
}
或者:
#include <iostream>
using namespace std;
class Single {
private:
Single() {} // 构造函数私有
Single(const Single &) {}; // 拷贝构造函数私有
Single& operator=(const Single&) {}; // 赋值操作符私有,不允许复制操作
static Single* _obj; // 指向属于类的对象
static int *a;// 该对象的其他数据
public:
virtual ~Single() {}
static Single* get_obj(){
return _obj;
}
static int get_data() {
return *a;
}
static void set_data(int a2) {
*a = a2;
}
};
Single* Single::_obj = new Single;
int* Single::a = new int(0);
int main()
{
Single::get_obj()->set_data(12);
cout << Single::get_obj()->get_data() << endl;
return 0;
}
加入了模板的饿汉式:
#include <iostream>
using namespace std;
template<typename T>
class Single {
private:
Single() {} // 构造函数私有
Single(const Single &) {}; // 拷贝构造函数私有
Single& operator=(const Single&) {}; // 赋值操作符私有,不允许赋值操作
static Single<T>* _obj; // 指向属于类的对象
static T* a;// 该对象的其他数据
public:
virtual ~Single() {}
static Single<T>* get_obj(){
return _obj;
}
static T get_data() {
return *a;
}
static void set_data(T a2) {
*a = a2;
}
};
template<typename T>
Single<T>* Single<T>::_obj = new Single<T>;
template<typename T>
T* Single<T>::a = new T;
int main()
{
Single<int>::get_obj()->set_data(12);
cout << Single<int>::get_obj()->get_data() << endl;
return 0;
}
精简版:
#include <iostream>
using namespace std;
template<typename T>
class Single {
private:
Single() {} // 构造函数私有
Single(const Single &) {}; // 拷贝构造函数私有
Single& operator=(const Single&) {}; // 赋值操作符私有,不允许赋值操作
static T* a;// 该对象的其他数据
public:
virtual ~Single() {}
static T* get_obj() {
return a;
}
};
template<typename T>
T* Single<T>::a = new T;
int main()
{
*(Single<int>::get_obj()) = 12;
cout << *(Single<int>::get_obj()) << endl;
return 0;
}
懒汉模式:
#include <iostream>
#include <mutex>
using namespace std;
template<typename T>
class Single {
private:
Single() {} // 构造函数私有
Single(const Single &) {}; // 拷贝构造函数私有
Single& operator=(const Single&) {}; // 赋值操作符私有,不允许赋值操作
static T* _point;
static mutex _mutex;
public:
virtual ~Single() {}
static T* get_obj(){
if (_point == NULL) {
_mutex.lock();
if (_point == NULL) {
_point = new T;
}
_mutex.unlock();
}
return _point;
}
};
template<typename T>
T* Single<T>::_point = new T;
template<typename T>
mutex Single<T>::_mutex;
int main()
{
*(Single<int>::get_obj()) = 12;
cout << *(Single<int>::get_obj()) << endl;
return 0;
}