目录
1、特殊类的设计
2、设计一个类,不能被拷贝
3、设计一个类,只能在堆上创建对象
4、设计一个类,只能在栈上创建对象
5、设计一个类,不能被继承
6、单例模式
1、饿汉模式
2、懒汉模式
1、特殊类的设计
在实际应用场景中,会存在一些特殊类的设计,比如:
设计一个只能在堆上创建对象的类,这样的设计可以用于需要动态管理内存,或者需要确保对象生命周期与程序控制流无关的场景中。
设计一个不能被拷贝的类,这样的设计常用于需要禁止对象被复制的场景,例如单例模式、线程池等。
在实际场景中,还有其他的特殊类设计,下面我们来列举几个。
2、设计一个类,不能被拷贝
如果让一个类不拷贝,只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。
在C++98中,将拷贝构造函数与赋值运算符重载只声明不定义,并且将其访问权限设置为私有即可。
class CopyBan
{
public:CopyBan(){}private:CopyBan(const CopyBan&);CopyBan& operator=(const CopyBan&);//...
};int main()
{CopyBan c;//CopyBan s(c);//CopyBan s=c;return 0;
}
而在C++11中,拓展了delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上=delete,表示让编译器删除掉该默认成员函数。
class CopyBan
{
public:CopyBan(){}CopyBan(const CopyBan&) = delete;CopyBan& operator=(const CopyBan&) = delete;//...
};
int main()
{CopyBan c;//CopyBan s(c);//CopyBan s=c;return 0;
}
3、设计一个类,只能在堆上创建对象
只能在对上创建对象,那么只能使用new来创建
1、私有化析构函数
这样在栈上创建对象会报错
2、可以使用私有的构造函数和析构函数,并通过静态成员函数返回堆上分配的对象指针。这样可以确保对象只能通过堆上的分配方式创建,而不能在栈上创建。
class HeapOnly {
private:// 私有构造函数和析构函数,防止在栈上创建对象HeapOnly() {}~HeapOnly() {}public:// 静态成员函数用于返回堆上分配的对象指针static HeapOnly* createObject() {return new HeapOnly();}
};int main()
{HeapOnly* h = HeapOnly::createObject();//HeapOnly s; return 0;
}
为防止通过拷贝构造在栈上创建对象,需要禁用拷贝构造和赋值重载。
// 声明拷贝构造函数和赋值运算符重载为私有,不实现它们HeapOnly(const HeapOnly&);HeapOnly& operator=(const HeapOnly&);
也可以使用C++11中的delete关键字。
4、设计一个类,只能在栈上创建对象
1、同上将构造函数私有化,然后设计静态方法创建对象返回即可
class StackOnly
{
public:static StackOnly CreateObj(){return StackOnly();}// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉// StackOnly obj = StackOnly::CreateObj();// StackOnly* ptr3 = new StackOnly(obj);void* operator new(size_t size) = delete;void operator delete(void* p) = delete;
private:StackOnly() :_a(0){}
private:int _a;
};
5、设计一个类,不能被继承
1、在C++98中可以将构造函数私有化派生类中调不到基类的构造函数。则无法继承
// C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
};
2、在C++11中使用final 关键字
final关键字,final修饰类,表示该类不能被继承。
class A final
{// ....
};
6、单例模式
单例模式是一种设计模式,用于确保类只有一个实例,并提供一个全局访问点。这在需要全局访问点且只需一个实例的情况下非常有用。
在单例模式中,类通常会提供一个静态成员函数来获取类的唯一实例,并且将构造函数设置为私有,以防止直接实例化类的对象。如果类的实例尚未创建,则静态成员函数会创建一个实例并返回它,否则会返回已存在的实例。
1、饿汉模式
// 饿汉模式
// 优点:简单
// 缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:static Singleton* GetInstance(){return &m_instance;}
private:// 构造函数私有Singleton() {};// C++98 防拷贝Singleton(Singleton const&);Singleton& operator=(Singleton const&);// or// C++11Singleton(Singleton const&) = delete;Singleton& operator=(Singleton const&) = delete;static Singleton m_instance;
};
Singleton Singleton::m_instance;
2、懒汉模式
懒汉模式是单例模式的另一种变体,它在需要时才创建实例,而不是在类加载时就创建。这种方式的优点是节省了内存,因为实例只在需要时才被创建,但需要考虑线程安全性。
#include <mutex>class Singleton {
private:// 静态成员变量,用于保存唯一实例static Singleton* instance;// 私有构造函数,防止外部实例化对象Singleton() {}// 互斥锁,用于保证线程安全static std::mutex mutex;public:// 静态成员函数,返回类的唯一实例static Singleton* getInstance() {// 在多线程环境下确保只有一个线程能够创建实例std::lock_guard<std::mutex> lock(mutex);// 如果实例尚未创建,则创建一个新实例if (!instance) {instance = new Singleton();}return instance;}
};// 在类外初始化静态成员变量
Singleton* Singleton::instance = nullptr;
// 初始化互斥锁
std::mutex Singleton::mutex;
在这个实现中,通过互斥锁确保了在多线程环境下的线程安全性。在调用Singleton::getInstance() 时,如果实例尚未创建,则会创建一个新实例并返回,否则会直接返回已存在的实例。