不能被拷贝的类
- C++98
将拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可。
class CopyBan
{
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};
私有是为了防止用户在类外自己定义。
- C++11
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};
不能被继承的类
- C++ 98
// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
};
- C++ 11
final
修饰
class A final
{
// ....
};
只能在栈上创建对象的类
构造函数私有化 + 删除operator new
class OnlyStack
{
public:
static OnlyStack Create(int a = 2, int* ptr = new int(55))
{
return OnlyStack();
}
~OnlyStack()
{
cout << "~OnlyStack()" << endl;
delete _ptr;
}
//static void* operator new(size_t size) = delete; 防止在堆上创建对象
private:
OnlyStack(int a = 2, int* ptr = nullptr)
: _a(a)
, _ptr(ptr)
{
if (_ptr == nullptr)
{
_ptr = new int(55);
}
}
int _a;
int* _ptr;
};
只能在堆上创建对象的类
- 析构函数私有化,通过调用函数销毁对象
class OnlyHeap
{
public:
OnlyHeap(int a = 2, int* ptr = nullptr)
: _a(a)
, _ptr(ptr)
{
if (_ptr == nullptr)
{
_ptr = new int(55);
}
}
void Destroy()
{
cout << "Destroy() : delete _ptr" << endl;
delete _ptr;
}
private:
~OnlyHeap()
{
cout << "~OnlyHeap()" << endl;
}
int _a;
int* _ptr;
};
- 构造函数私有化 + 防拷贝
class OnlyHeap
{
public:
static OnlyHeap* Create(int a = 2, int* ptr = new int(55))
{
OnlyHeap* temp = new OnlyHeap({ a, ptr });
return temp;
}
~OnlyHeap()
{
cout << "~OnlyHeap()" << endl;
delete _ptr;
}
private:
OnlyHeap(const OnlyHeap& temp) = delete;
OnlyHeap& operator=(const OnlyHeap& temp) = delete;
OnlyHeap(int a = 2, int* ptr = nullptr)
: _a(a)
, _ptr(ptr)
{
if (_ptr == nullptr)
{
_ptr = new int(55);
}
}
int _a;
int* _ptr;
};
单例模式
只能创建一个对象的类,该模式可以保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块共享
饿汉模式
在程序启动前创建好对象
class Single
{
static Single* GetInstance()
{
return &s;
}
private:
Single();
Single(const Single& temp) = delete;
Single& operator=(const Single& temp) = delete;
int _a;
static Single s;
};
Single Single::s;
懒汉模式
第一次使用时创建对象
class Single
{
public:
static Single* GetInstance()
{
if (nullptr == s)
s = new Single();
return s;
}
private:
Single();
Single(const Single& temp) = delete;
Single& operator=(const Single& temp) = delete;
int _a;
static Single* s;
};
Single* Single::s = nullptr;