C++特殊类的设计

文章目录

  • 设计一个类不能被拷贝
  • 请设计一个类,只能在堆上创建对象
  • 设计一个类只能在栈上去创建对象
  • 设计一个类不能被继承
  • 设计一个类,只能创建一个对象(单例模式)
    • 饿汉模式
    • 懒汉模式
  • 单例模式总结
    • 饿汉模式
    • 懒汉模式

设计一个类不能被拷贝

拷贝一个类对象可以有两种方式,分别是拷贝构造和赋值运算符重载函数,因此要想一个类不能被拷贝,只需在这两个函数上做文章就可以了。
1.只声明不定义(因为定义也没啥意义,反正也不会调用该函数),且设为私有函数
为什么要设为私有函数呢?
如果只声明为public的,可能用户会自己在类外进行定义实现,那么这个类就变得可以被拷贝了。

private:
	A(const A& a)
	{

	}

	A& operator=(const A& a)
	{

	}

2.把这两个函数给禁掉(C++11)

A(const A& a) = delete;
A& operator=(const A& a) = delete;

C++11中,通过关键字delete来禁用函数,如果在一个函数后面加上=delete就表示删除该默认成员函数

请设计一个类,只能在堆上创建对象

提供一个静态成员函数,该函数完成对象在堆上的创建,把构造函数设为私有,并把该类的拷贝构造函数和赋值运算符重载函数设成私有或者禁掉,防止别人调用在栈上生成对象。

class HeapOnly
{
public:
	static HeapOnly* CreatObject()
	{
		return new HeapOnly();
	}

private:
	HeapOnly()
	{

	}

	HeapOnly(const HeapOnly& hp) = delete;
	HeapOnly& operator=(const HeapOnly& hp) = delete;

};

这里为什么要把CreatObject设为static呢?
因为我们的返回值是new HeapOnly()创建这个对象,而如果不加static的话就需要先有HeapOnly()这个对象,才能去调用这个函数,而加了static修饰这个函数之后,这个函数就变成了属于属于这个类的了而不是这个对象的了,从而可以通过类去调用这个函数了

设计一个类只能在栈上去创建对象

通过静态成员函数去调用构造函数去创建对象,并把new和delete关键字给禁掉

class StackOnly
{
public:
	static StackOnly GetInstance()
	{
		return StackOnly();
	}

	void* operator new(size_t size) = delete;
 	void operator delete(void* p) = delete;
	
private:
	StackOnly()
		:_a(0)
	{

	}
	int _a;
};

设计一个类不能被继承

方法一:把基类的构造函数私有化

#include 

using namespace std;

class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}

private:
	NonInherit()
	{

	}
};

class A : public NonInherit
{
private:
	int _a;
};

方法二:使用C++11关键字final进行修饰

#include 

using namespace std;

class NonInherit final
{
};

class A : public NonInherit
{
};

设计一个类,只能创建一个对象(单例模式)

**单例模式:一个类只能创建一个对象,即单例模式,该模式可以保证系统中只有一个实例,并提供一个访问他的全局访问点,该实例被所有程序模块共享。**比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,这种方式简化了在复杂环境下的配置管理。

饿汉模式

#include 

using namespace std;

class Singleton
{
public: 
	static Singleton& GetInstance()
	{
		return _instance;
	}

private:
	Singleton()
	{
		cout << "Singleton()" << endl;
	}

	Singleton(const Singleton& _instance) = delete;
	Singleton& operator=(const Singleton& instance) = delete;

	static Singleton _instance;
};

Singleton Singleton::_instance;
int main()
{
	/* Singleton a;
	 Singleton b;*/
	
	cout << &Singleton::GetInstance()<< endl;
	cout << &Singleton::GetInstance() << endl;

	return 0;
}

类中的静态成员变量_instance是就是这个类对象,它是属于这个类的,且在函数体外进行了定义,所以在进入main函数之前该成员变量就被创建了。且在进入main函数之后,如果想再创建对象就必须调用类中的静态成员函数,而该函数返回的对象就是我们进入main函数之前创建的那个静态成员变量_instance,所以保证了每一次的得到的对象都是同一个。因为构造函数被私有,在后续创建对象时我们通过GetInstance()来创建对象时,不会调用构造函数,而是直接返回成员变量_instance

Singleton()
{
	cout << "Singleton()" << endl;
}

在进入main函数之前这句话就打印了,进入main函数之后创建对象时,因为不会在调用搞糟函数,所以这句话不会再被打印
C++特殊类的设计_第1张图片
饿汉模式缺点:如果类之间有依赖关系,或者占用空间过大就会导致启动速度减慢,需要花较长的时间才能进入main函数

懒汉模式

为什么叫懒汉模式?
因为该对象会在进入main函数之后,当你手动去创建时才会创建,而且在第一次之后创建的对象都与第一个是同一个
这里通过一个静态成员对象指针变量来控制,创建的是同一个,先给这个对象指针赋值为nullptr,当它为nullptr时,才给你创建对象,并把所创建对象的地址给静态成员变量指针,当不为nullptr时,你调用成员函数GetInstance()得到的是这个静态成员对象指针的解引用,也就是第一一次创建的对象的地址

#include 

using namespace std;

class Singleton
{
public:
	static Singleton& GetInstance()
	{
		if (_instance == nullptr)
		{
			_instance = new Singleton;
			return *_instance;
		}
		return *_instance;
	}

	Singleton(const Singleton& sl) = delete;
	Singleton operator=(const Singleton& sl) = delete;

private:
	Singleton()
	{

	}

	static Singleton* _instance;//单例对象指针
};

Singleton* Singleton::_instance = nullptr;

int main()
{
	cout << &Singleton::GetInstance() << endl;
	cout << &Singleton::GetInstance() << endl;
	//错误	C2280	“Singleton::Singleton(const Singleton&)”: 尝试引用已删除的函数
	//Singleton s = Singleton::GetInstance();
	return 0;
}

单例模式总结

饿汉模式

不管你将来是不是用这个实例对象,只要程序启动这个对象就被实例化出来,且全局始终只有这一个实例化对象。
优点:简单
缺点:可能会导致进程启动变慢,且如果有多个单例类对象实例,启动顺序不确定。如果这个单例对象在多线程高并发情况下频繁使用,性能要求较高,那么显然使用饿汉模式来避免资源竞争,提高响应速度更好。

懒汉模式

如果单例对象构造十分耗时或者占用资源,比如加载组件,初始化网络链接,读取文件等,且有可能这个对象在该程序运行时并不会被用到,那么在程序启动前就进行初始化就会导致程序启动非常缓慢,所以这种情况下,选用懒汉模式(延时加载)更好。

你可能感兴趣的:(C++,c++)