【C++学习】C++特殊类的设计

2024-04-15 10:00:02
开发
13

文章标题

1.请设计一个类，不能被实例化

分析：
拷贝只会放生在两个场景中：拷贝构造函数以及赋值运算符重载，因此想要让一个类禁止拷贝，只需让该类不能调用拷贝构造函数以及赋值运算符重载即可。

C++98 将构造函数放在私有且只放声明，不放定义。

//C++98
//将类的构造函数私有，且只放声明，没有定义
template<class T>
class NOInstantiation
{
private:
	NOInstantiation();
	T _a;
	vector<T> _vi;
};

这样做的好处：

构造函数私有，类外面不能访问，就不能构造。
构造函数没有定义，只有声明，再类里面也不能实例化。

C++11 利用关键字delete
C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。

//C++11  使用 delete关键字
template<class T>
class NOInstantiation
{
public:
	NOInstantiation() = delete;
private:
	T _a;
	vector<T> _vi;
};

2.请设计一个类，不能被拷贝

C++98
将拷贝构造与复制拷贝私有，且只有定义没有声明。

//C++98
template<class T>
class NOInstantiation
{
public:
	NOInstantiation()
	{}
private:
	NOInstantiation(const NOInstantiation& NI);
	NOInstantiation& operator=(const NOInstantiation& NI);

	T _a;
	vector<T> _vi;
};

C++11 和上面一样，使用delete关键字

//C++11
template<class T>
class NOInstantiation
{
public:
	NOInstantiation()
	{}
	NOInstantiation(const NOInstantiation& NI) = delete;
	NOInstantiation& operator=(const NOInstantiation& NI) = delete;
private:
	T _a;
	vector<T> _vi;
};

3. 请设计一个类，只能在堆上创建对象

方法1：

实现方式
1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
3. 需要将拷贝构造与赋值拷贝禁掉
代码实现：

//只能在Heap上开空间
template<class T>
class HeapOnly
{
public:
	template<class ...Args>
	static HeapOnly* CreatObj(Args&&...args)
	{
		return new HeapOnly(args...);
	}
	HeapOnly(const HeapOnly& ho) = delete;
	HeapOnly& operator=(const HeapOnly& ho) = delete;

private:
	HeapOnly()
	{}
	HeapOnly(const T& x,const T& y)
		:_x(x)
		,_y(y)
	{}
	T _x ;
	T _y ;
	vector<string> v;
};
int main()
{
	//HeapOnly<int> ho1;
	//HeapOnly<int> ho2(10,20);

	HeapOnly<int>* ho = HeapOnly<int>::CreatObj(10, 20);
	
	//HeapOnly<int> ho3(*ho);
	//HeapOnly<int> ho4 = (*ho);

	return 0;
}

方法2：

实现方式
1. 将类的析构函数私有，析构函数是自动调用的，所以不能在栈上创建对象。
2. 添加一个成员函数来释放空间。delete一个类对象，会先去调用类的析构函数，然后释放空间。

代码实现：

template<class T>
class HeapOnly
{
public:
	void destory()
	{
		delete this;
	}
private:
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}
	T _x ;
	T _y ;
	vector<string> v;
};
int main()
{
	HeapOnly<int>* ho = new HeapOnly<int>;
	ho->destory();

	//使用智能指针 shared_ptr 时
	//shared_ptr 默认的删除器是使用delete，但是这里delete调不动，所以需要自己写一个删除器
	shared_ptr<HeapOnly<int>> p(new HeapOnly<int>, [](HeapOnly<int>* ptr) {ptr->destory(); });

	return 0;
}

4. 请设计一个类，只能在栈上创建对象

实现方式
1. 将构造函数私有，定义一个静态成员函数调用私有的构造函数，然后返回对象。
2. 因为在调用StackOnly CreatObj的时候，是值返回，需要拷贝构造，所以只需要🈲掉赋值拷贝被即可。
3. 当这样创建对象的时候（如下），还是可以在堆区创建对象，解决方法：禁掉operator new
  new一个类对象的时候，new实际上是调用operator new与该类的构造函数（拷贝构造也是构造函数），类里面不重载的话默认的是调用全局的operator new，所以，我们这里不能封拷贝构造，只能将operator new封掉。

     StackOnly<int> ho1 = StackOnly<int>::CreatObj(10, 20);
     //StackOnly<int>* ho4 = new StackOnly<int>(ho1);

代码实现：

//只能在Stack上开空间
template<class T>
class StackOnly
{
public:
	template<class ...Args>
	static StackOnly CreatObj(Args&&...args)
	{
		return StackOnly(args...);
	}
	StackOnly& operator=(const StackOnly& ho) = delete;
	void* operator new(size_t n) = delete;   

private:
	StackOnly()
	{}
	StackOnly(const T& x, const T& y)
		:_x(x)
		, _y(y)
	{}

	T _x;
	T _y;
	vector<string> v;
};

5.请设计一个类，不能被继承

C++98的方式：将基类的构造函数私有，因为派生在在实例化时需要调用基类的构造函数。
C++11后：使用final关键字
虚函数不能被重写也是加final关键字。
代码演示：

//加final即可
class A final
{

};

6. 请设计一个类，只能创建一个对象(单例模式)

设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

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

饿汉模式
就是说不管你将来用不用，程序启动时（main函数之前）就创建一个唯一的实例对象。

优缺点:
优点：简单
缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

使用场景： 如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

代码实现：

class singletin
{
public:
	static singletin& GetInstantiance()
	{
		return _tin;
	}

	singletin(const singletin& sl) = delete;
	singletin& operator=(const singletin& sl) = delete;
	void Print()   //打印，方便查看
	{
		cout << _x << endl;
		cout << _y << endl;
		for (auto e : _vi)
		{
			cout << e << " ";
		}
		cout << endl;
	}
	void push_back(const int x)  //修改数据
	{
		_vi.push_back(x);
	}

private:
	singletin(int x = 0, int y = 0, const vector<int> vi = {0})
		:_x(x)
		,_y(y)
		,_vi(vi)
	{}

	int _x;
	int _y;
	vector<int> _vi;

	static singletin _tin;
};
singletin singletin::_tin(22, 12, {2,3,4,5});
int main()
{
	singletin::GetInstantiance().Print();
	
	singletin::GetInstantiance().push_back(100);
	singletin::GetInstantiance().Print();

	return 0;
}

懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊，初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。所以这种情况使用懒汉模式（延迟加载）更好。

优缺点：
优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
缺点：复杂

代码实现：

class singletin
{
public:
	static singletin* GetInstantiance(int x = 0, int y = 0, const vector<int>& vi = { 0 })
	{
		if (_ptr == nullptr)
		{
			_ptr = new singletin(x, y, vi);
		}
		return _ptr;
	}
	static void DelInstantiance()
	{
		if (_ptr)
		{
			delete _ptr;
		}
		_ptr = nullptr;
	}
	singletin(const singletin& sl) = delete;
	singletin& operator=(const singletin& sl) = delete;
	
	void Print()   //打印，方便查看
	{
		cout << _x << endl;
		cout << _y << endl;
		for (auto &e : _vi)
		{
			cout << e << " ";
		}
		cout << endl;
	}
	void push_back(const int x)  //修改数据
	{
		_vi.push_back(x);
	}
	class GC   //增加一个GC类，是为了怕忘记释放
	{
		~GC()  //Gc的析构函数去调用singletin的DelInstantiance函数
		{
			singletin::DelInstantiance();
		}
	private:
		static GC gc;  //定义一个静态对象
	};

private:
	singletin(int x, int y, const vector<int>& vi)
		:_x(x)
		, _y(y)
		, _vi(vi)
	{}
	~singletin()
	{
		//可以在里面进行操作，假设需要在析构前将信息写入文件
		cout << "~singletin()" << endl;
	}
	int _x;
	int _y;
	vector<int> _vi;

	static singletin* _ptr;
};
singletin* singletin::_ptr = nullptr;
singletin::GC singletin::GC:: gc;

int main()
{
	singletin::GetInstantiance()->push_back(100);

	singletin::GetInstantiance()->Print();

	singletin::GetInstantiance()->push_back(100);
	singletin::GetInstantiance()->Print();

	return 0;
}

原文地址:https://blog.csdn.net/2301_77509762/article/details/137715772 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1779691117831393280.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部