C++的特殊类设计 && 饥饿汉模式

无聊看看天T^T

于 2024-06-23 22:55:37 发布

阅读量825

点赞数 9

分类专栏： C++从入门到入土文章标签： c++ 算法

本文链接：https://blog.csdn.net/m0_73975164/article/details/139635869

版权

C++从入门到入土专栏收录该内容

36 篇文章 1 订阅

订阅专栏

特殊类设计

设计一个不能被拷贝的类

C++98的设计方式：将该类的拷贝构造和赋值运算符重载函数均只声明不定义，并将它们的访问权限设置为私有

class CopyBan
{
    // ...

//设置为私有
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
    //...
};

只声明不定义：本就不会使用再定义没意义，且如果有定义的话虽然设置了private，但只是为了防外部人调用的，但类内部的其它成员还可以使用拷贝构造和赋值重载

template<class T>
class SmartPtr
{
public:
    // RAII
    SmartPtr(T* ptr)
	    :_ptr(ptr)
    {}

    //...
    void Printf()
    {
	    SmartPtr<int> s1(new int(2));
	    SmartPtr s2(s1);
    }

private:

    //拷贝构造
    SmartPtr(const SmartPtr& s)
    {
    	cout << "SmartPtr(const SmartPtr& s)" << endl;
    }

    T* _ptr;
};

设置为private：只声明不设置为private，外部用户就可以在类外实现这两个函数的定义

class Example {
public:
	Example() {};

	//只声明不定义
	Example(const Example& e);//拷贝构造
	Example& operator=(const Example& e);//赋值重载
};

// 在类外部定义 拷贝构造 和 赋值重载
Example::Example(const Example& e)
{
	cout << "Example(const Example& e)\n";
}

Example& Example::operator=(const Example& e)
{
	cout << "Example& Example::operator=(const Example& e)\n";
	return *this;
}

int main()
{	// 使用类外定义的 拷贝构造 和 赋值重载
	Example e1;
	Example e2(e1);

	e2 = e1;
	return 0;
}

C++11的设计方式：使用=delete的方法，在成员函数后加上=delete，那么编译器就不会生成该成员函数的定义（不需要再使用private限制了，但仍需声明）

class CopyBan
{
    // ...
    CopyBan(const CopyBan&)=delete;
    CopyBan& operator=(const CopyBan&)=delete;
    //...
};

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

设计方式：将构造函数设为私有，防止用户在类外调用构造函数从而在栈上生成对象，然后再定义一个public权限的静态成员函数，该函数用于在堆上创建该类的对象并返回该对象的指针

补充：还需要将拷贝构造和赋值重载也设置为只声明不定义 + 访问权限为private 或者 =delete，防止用户调用默认的拷贝构造在栈上生成该类的对象

class HeapOnly
{
public:
    //静态成员函数：可以直接通过类名调用，而不需要类的对象实例
    static HeapOnly* CreatObj()
    {
        return new HeapOnly;//在堆上new一个HeapOnly类型的匿名对象，并返回该对象的指针   
    }
    HeapOnly(const HeapOnly& e)=delete;
    HeapOnly& operator=(const HeapOnly& e)=delete;
private:

    HeapOnly() {};//默认构造函数
 
};

int main()
{
    //HeapOnlye1;//错误,不可访问
    //HeapOnly* e2 = CreatObj();//错误，找不到该函数
    HeapOnly* e2 = HeapOnly::CreatObj();

    //HeapOnlye3(*e2);//尝试调用拷贝构造在栈上生成一个该类的对象
    return 0;
}

还可以加上多参数模板，实现传递多个参数进行构造，当然构造函数也要提供合适的版本

class HeapOnly
{
public:
    template<class... Args>
    static HeapOnly* CreateObj(Args&&... args)
    {
	    return new HeapOnly(args...);
    }

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

private:

//无参构造
HeapOnly()
{}

//接收两个参数的构造函数
HeapOnly(int x, int y)
	:_x(x)
	,_y(y)
{}

};

int main()
{
	HeapOnly* ho3 = HeapOnly::CreateObj();
	HeapOnly* ho4 = HeapOnly::CreateObj(1,1);
    return 0;
}

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

设计方式：构造函数设为私有，设计一个合适的静态成员函数，拷贝构造不用=delete限制、赋值重载需要=delete限制

class StackOnly
{
public:
    template<class... Args>
    static StackOnly CreateObj(Args&&... args)
    {
        return StackOnly(args...);//用于返回在栈上创建的一个匿名对象的静态成员函数，返回类型不是StackOnly*而是StackOnly 
    }

    //只封住了赋值重载
    StackOnly& operator=(const StackOnly&) = delete;

private:
    //无参默认构造函数
    StackOnly() 
    {
        cout << "StackOnly()" << endl;
    };
    StackOnly(int x,int y)//支持两个参数的默认构造函数
        :_x(x)
        ,_y(y)
    {
        cout << "StackOnly(int x,int y)" << endl;
    };
    int _x;
    int _y;
};

int main()
{
    StackOnly ho1 = StackOnly::CreateObj();
    StackOnly ho2 = StackOnly::CreateObj(1, 1);

    StackOnly* ho3 = new StackOnly(ho1);//没有=delete拷贝构造,就可以使用系统提供的默认拷贝构造
    //通过反汇编可以看到是先new在堆上分配了一个8字节大小的内存，然后将调用默认拷贝构造生成的匿名对象放入该内存中，最后返回该对象的地址给ho3
    return 0;
}

new + 拷贝构造也可以在堆上创建对象，所以我们可以直接重写一个new，并=delete该new

//重载一个类专属的operator new，此时再去new StackOnly就不会去调用全局的operator new
void* operator new(size_t n) = delete;

设计一个不能继承的类

C++98的设计方式：构造函数私有化，派生类中调不到基类的构造函数。则无法继承

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

    NonInherit()
     {}
};

C++11的设计方式：final关键字，final修饰一个类，表示该类不能被继承

class A  final
{
    // ....
};

设计模式

基本概念：设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结，使用设计模式的目的是为了代码的可重用性、让代码更容易被他人理解、保证代码可靠性，设计模式使得代码编写真正工程化

单例模式

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

饿汉模式

#include <iostream>
#include <vector>
using namespace std;

namespace hunger 
{
	//饿汉:执行main之前就创建出一个对象
	class Singleton
	{
	public:
		static Singleton* GetInstance()
		{
			return &_sint;//返回静态成员对象的地址
		}

		void Print()
		{
			cout << _x << _y << endl;

			for (auto& e : _vstr)
			{
				cout << e << " ";
			}
			cout << endl;
		}

		//修改数据
		void AddStr(const string& s)
		{
			_vstr.push_back(s);
		}

		//将拷贝构造和赋值重载禁掉，防止用户*指针然后调用拷贝构造新建对象
		Singleton(Singleton const&) = delete;
		Singleton& operator=(Singleton const&) = delete;

	private:
		//构造函数:数据被放入数组中存放
		Singleton(int x = 0, int y = 0, const vector<string>& vstr = { "yyyyy","xxxx" })
			:_x(x)
			,_y(y)
			,_vstr(vstr)
		{}

		// 想让一些数据，当前程序只有一份，可以把这些数据放到一个类里，然后再把这个类设计成单例，这样数据就只有一份了
		int _x;
		int _y;
		vector<string> _vstr;

		//类的静态成员对象，属于该类实例化出的所有对象，存在于静态区，在类中声明，使用时受类域限制（加类名）
		static Singleton _sint;

	};

	Singleton Singleton::_sint(1, 1, { "陕西","四川" });
}

int main()
{
	hunger::Singleton::GetInstance()->Print();
	hunger::Singleton::GetInstance()->AddStr("甘肃");
	hunger::Singleton::GetInstance()->Print();
	hunger::Singleton::GetInstance()->AddStr("甘肃");
	hunger::Singleton::GetInstance()->Print();
	return 0;
}

缺点1：影响程序启动速度，若单例对象数据过多，构造静态成员对象的成本变高，导致迟迟进不了main函数（长时间不登录微信，拉取消息时很慢，可以通过多线程解决，比如用于拉取群聊消息的单例是一个线程，用于拉去单个用户消息的单例是一个线程，那么拉取群聊消息的单例的初始化速度缓慢不会影响拉取单个用户消息的单例的初始化速度）

缺点2：多个单例类有初始化启动依赖关系，饿汉无法控制（A和B两个单例，若要求A先初始化，B再初始化，饿汉无法保证）

缺点3：无法处理异常，在饿汉模式中，如果单例对象在实例化时抛出异常，整个类加载过程都会失败

饥汉模式

#include <iostream>
#include <vector>
using namespace std;

namespace lazy
{
	class Singleton
	{
	public:
		static Singleton* GetInstance()
		{
			// 第一次调用时，创建单例对象，第二次时_psint就不为空，进入该函数也只是返回_psint
			//存在线程安全问题，需要加锁
			if (_psint == nullptr)
			{
				_psint = new Singleton;//可能需要释放
			}

			return _psint;
		}

		static void DelInstance()
		{
			//释放 + 置空
			if (_psint)
			{
				delete _psint;
				_psint = nullptr;
			}
		}

		void Print()
		{
			cout << _x << endl;
			cout << _y << endl;

			for (auto& e : _vstr)
			{
				cout << e << " ";
			}
			cout << endl;
		}

		void AddStr(const string& s)
		{
			_vstr.push_back(s);
		}

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

	private:
		Singleton(int x = 0, int y = 0, const vector<string>& vstr = { "yyyyy","xxxx" })
			:_x(x)
			, _y(y)
			, _vstr(vstr)
		{}

		~Singleton()
		{
			// 把数据写到文件
			cout << "~Singleton()" << endl;
		}


		int _x;
		int _y;
		vector<string> _vstr;
		static Singleton* _psint;

		// 内部类，用于防止用户忘记显示调用DelInstance释放对象
		//实例化一个静态内部类成员对象（全局生命周期），当程序结束时就会调用GC类对象的析构进而调用DelInstance
		class GC
		{
		public:
			~GC()
			{
				Singleton::DelInstance();
			}
		};
		static GC gc;//不实例化GC类对象，该类没用不会调用该类的析构函数
	};

	// 两个静态成员对象在类外的定义
	Singleton* Singleton::_psint = nullptr;
	Singleton::GC Singleton::gc;//什么都不做
}

int main()
{
	lazy::Singleton::GetInstance()->Print();
	lazy::Singleton::GetInstance()->AddStr("甘肃");
	lazy::Singleton::GetInstance()->Print();
	lazy::Singleton::GetInstance()->AddStr("甘肃");
	lazy::Singleton::GetInstance()->Print();

	//lazy::Singleton::DelInstance();//显示调用DelInstance可以释放，不显示也可以（注释和非注释两次运行试一试即可）
	return 0;
}

补充：也可以选择不用上述的内部类和指针的情况（需要注意显示调用和释放），而是在GetInstance中定义一个局部的静态成员对象，该成员会在第一次调用GetInstance函数时构造初始化一次且仅有一次（局部静态成员对象只能被初始化一次），但只有在C++11及之后才能使用

static Singleton* GetInstance()
{
	// 局部的静态对象，第一次调用函数时构造初始化
	// C++11及之后这样写才可以
	// C++11之前无法保证这里的构造初始化是线程安全
	static Singleton _sinst;
	return &_sinst;
}