特殊类的创建

清风玉骨2026-02-06 11:40

目录

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

C++98

C++11

实例

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

实例

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

实例

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

C++98

C++11

实例

设计模式

单例模式

饿汉模式

懒汉模式

实例

C++11之前的懒汉模式

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

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

C++98

将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可

cpp 复制代码 
class CopyBan
{
// ...
private:
CopyBan(const CopyBan&);
CopyBan& operator=(const CopyBan&);
//...
};

原因：

  1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不

能禁止拷贝了

  1. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写

反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11

cpp 复制代码 
class CopyBan
{
// ...
CopyBan(const CopyBan&)=delete;
CopyBan& operator=(const CopyBan&)=delete;
//...
};

实例

cpp 复制代码 
//该类不能发生拷贝
class Nocopy {
public :
	Nocopy(int i = 0)
		:_i(i)
	{}


	Nocopy(const Nocopy&)=delete;
	Nocopy&operator=(const Nocopy&) = delete;
private:
	int _i;
};

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

实现方式：

  1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

  2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建

cpp 复制代码 
class HeapOnly
{
public:
    static HeapOnly* CreateObject()
    {
        return new HeapOnly;
    }
private:
    HeapOnly() {}
    // C++98
    // 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
    // 2.声明成私有
    HeapOnly(const HeapOnly&)；

    // or
    // C++11
    HeapOnly(const HeapOnly&) = delete;
};

实例

cpp 复制代码 
class HeapOnly {
public:
	HeapOnly()
	{}

	void Destory()
	{
		this->~HeapOnly();
	}

private:
                //析构函数私有之后，因为编译器检测到无法正常释放，所以不支持创建
	~HeapOnly()	//析构变为私有
	{}

	HeapOnly(const HeapOnly&) = delete;	// 防止拷贝构造(在栈上创建对象)
};

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

方法一：同上将构造函数私有化，然后设计静态方法创建对象返回即可

cpp 复制代码 
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;
};

实例

cpp 复制代码 
//只能在栈上面创建对象 -- 但是无法很好的解决静态的创建
class StackOnly
{
public:
	static StackOnly CreateObj()
	{
		return StackOnly();
	}
	
	//方式3，全部封死，只提供接口使用，但是这样的对象是无法改变的
	void Print() const
	{
		std::cout << "StackOnly::Print()" << std::endl;
	}


	/* 方式2
	也用这样用的，封掉new和delete，并且把构造放出来，但是这样可以封掉堆上的，但是还是封不掉静态的
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
	*/

	/*StackOnly(StackOnly&& so)  右值引用，无法很好的解决
	{}*/

    //	方式3，全部封死，只提供接口使用，但是这样的对象是无法改变的
    //	void Print() const
    //	{
    //		std::cout << "StackOnly::Print()" << std::endl;
    //	}


private:
	StackOnly()
	{}

	StackOnly(const StackOnly&) = delete;

};
cpp 复制代码 
int main()
{
	/* 方式1
	StackOnly so1 = StackOnly::CreatObj();
	static StackOnly so2 = StackOnly::CreatObj();	//静态的成员创建无法封死,这一点是无法避免的
	*/

	//static StackOnly so3;	方式2无法封掉这一行，静态的创建
	//StackOnly* pso3 = new StackOnly;	方式2可以封掉堆上面创建的，因为new会调用构造

	//方式3 
	StackOnly::CreateObj().Print();

	const StackOnly& so4 = StackOnly::CreateObj();    //无法禁止
	so4.Print();


	return 0;
}

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

C++98

cpp 复制代码 
// C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
class NonInherit
{
public:
    static NonInherit GetInstance()
    {
        return NonInherit();
    }
private:
    NonInherit()
    {}
};

C++11

final关键字，final修饰类，表示该类不能被继承。

cpp 复制代码 
class A final
{
    // ....
};

实例

cpp 复制代码 
//该类不能被继承
//C++98
class NoInherit
{
public:
private:
	int* _i;
	NoInherit(int* i)
		:_i(i)
	{}
};


class NoInherit1 : public NoInherit
{

};

//C++11 使用final关键字可以解决
class NoInheritC11 final
{
public :
	NoInheritC11()
	{}
private:
	int* i;
};


class NoInheritC11_1 : public NoInheritC11
{

};

设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样

单例模式

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

单例模式有两种实现模式：

饿汉模式

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避

免资源竞争，提高响应速度更好。

cpp 复制代码 
// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
    public:
    static Singleton* GetInstance()
    {
        return &m_instance;
    }
private:
    // 构造函数私有
    Singleton(){};
    // C++98 防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    // or
    // C++11
    Singleton(Singleton const&) = delete;
    Singleton& operator=(Singleton const&) = delete;
    static Singleton m_instance;
};
Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化

懒汉模式

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

cpp 复制代码 
// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控
制。
// 缺点：复杂
#include <iostream>
#include <mutex>
#include <thread>
using namespace std;
class Singleton
{
public:
    static Singleton* GetInstance() {
    // 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
    if (nullptr == m_pInstance) {
        m_mtx.lock();
    if (nullptr == m_pInstance) {
        m_pInstance = new Singleton();
    }
        m_mtx.unlock();
    }
        return m_pInstance;
    }
// 实现一个内嵌垃圾回收类
class CGarbo {
public:
    ~CGarbo(){
        if (Singleton::m_pInstance)
            delete Singleton::m_pInstance;
      }
};

// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
    static CGarbo Garbo;
private:
    // 构造函数私有
    Singleton(){};
    // 防拷贝
    Singleton(Singleton const&);
    Singleton& operator=(Singleton const&);
    static Singleton* m_pInstance; // 单例对象指针
    static mutex m_mtx; //互斥锁
};
    Singleton* Singleton::m_pInstance = nullptr;
    Singleton::CGarbo Garbo;
    mutex Singleton::m_mtx;

int main()
{
    thread t1([]{cout << &Singleton::GetInstance() << endl; });
    thread t2([]{cout << &Singleton::GetInstance() << endl; });
    t1.join();
    t2.join();
    cout << &Singleton::GetInstance() << endl;
    cout << &Singleton::GetInstance() << endl;
    return 0;
}

实例

cpp 复制代码 
//单例:全局只有一个类
//饿汉模式：一开始(main函数之前)就创建对象
//缺点：1、单例对象初始化时数据太多，会导致启动慢
//		2、多个单例类有初始化依赖关系，饿汉模式无法控制
//比如：A和B都是单例类，要求先初始化A，再初始化B，因为B会依赖A，所以无法控制，饿汉模式无法控制顺序
class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		return _sins;
	}


	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}


	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}


private:
	InfoSingleton() 
	{}


	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;

	map<string, int> _info;
private:
	static InfoSingleton _sins;	//定义成类里面的成员，就可以调用构造函数了，没有这一句外部定义不了全局的变量
								//而单例就需要一个全局的变量
};
InfoSingleton InfoSingleton::_sins;

//懒汉模式
//1、对象在main函数之后才会创建对象，不影响启动顺序
//2、可以主动控制创建对象的顺序
//下面的方式是懒汉。因为静态的局部变量是在main函数之后才创建初始化的
//注意 C++11之前，这里是不能保证sinst的初始化是线程安全的
//    C++11之后，可以保证

class InfoSingleton
{
public:

	//多个线程一起调用GetInstance，存在线程安全的风险，所以需要加锁
	static InfoSingleton& GetInstance()
	{
		static InfoSingleton sinst;
		return sinst;
	}


	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}


	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}


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


	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;


	map<string, int> _info;


};

C++11之前的懒汉模式

cpp 复制代码 
//懒汉模式：第一次获取单例对象的时候创建对象
//1、对象在main函数之后才会创建对象，不影响启动顺序
//2、可以主动控制创建对象的顺序
template<class Lock>
class LockGuard
{
public:
	LockGuard(Lock& lk)
		:_lk(lk)
	{
		_lk.lock();
	}

	~LockGuard()
	{
		_lk.unlock();
	}

private:
	Lock& _lk;	//锁不允许拷贝,所以使用引用
};

class InfoSingleton
{
public:
	//加锁方式1 -- 原始版本
	//多个线程一起调用GetInstance，存在线程安全的风险，所以需要加锁
	//static InfoSingleton& GetInstance()
	//{
	//	//第一次获取单例对象的时候创建
	//	//双检查加锁 -- 为了减少加锁与解锁的性能消耗
	//	if (_psins == nullptr)
	//	{
	//		_smtx.lock();
	//		try
	//		{
	//			if (_psins == nullptr)
	//			{
	//				_psins = new InfoSingleton;	//new 可能会抛异常，所以可能没有解锁
	//			}								//所以需要try catch一下
	//		}
	//		catch (...)
	//		{
	//			_smtx.unlock();
	//			throw;
	//		}
	//		_smtx.unlock();
	//	}
	//	return *_psins;
	//}

	//多个线程一起调用GetInstance，存在线程安全的风险，所以需要加锁
	static InfoSingleton& GetInstance()
	{
		//第一次获取单例对象的时候创建
		//双检查加锁 -- 为了减少加锁与解锁的性能消耗
		if (_psins == nullptr)
		{
			//LockGuard<mutex> lock(_smtx);	//锁不允许拷贝 -- 自己写的
			std::lock_guard<mutex> lock(_smtx);    //库里面的
			if (_psins == nullptr)
			{
				_psins = new InfoSingleton;	//new 可能会抛异常，所以可能没有解锁
			}								//所以需要try catch一下
		}
		return *_psins;
	}
	//一般单例对象不需要考虑释放
	//当单例对象不用时，必须手动释放，一些资源需要保存 -- 特殊场景
	//可以手动调用回收
	//也可以让它自己回收 -- 不过大多数的单例是不需要释放，因为进程结束会自己释放的
	static void DeleteInstance()
	{
		//保存数据到文件
		//...

		std::lock_guard<mutex> lock(_smtx);
		if (_psins)
		{
			delete _psins;
			_psins = nullptr;
		}
	}
	//自动回收资源 -- 内部类天生是外部内的友元函数
	class GC
	{
	public:
		~GC()
		{
			if (_psins)	//当已经释放过了就不需要再释放了
			{
				cout << "~GC()" << endl;
				DeleteInstance();
			}
		}
	};

	void Insert(string name, int salary)
	{
		_info[name] = salary;
	}

	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}

private:
	InfoSingleton()
	{}

	InfoSingleton(const InfoSingleton& info) = delete;
	InfoSingleton& operator=(const InfoSingleton& info) = delete;

	map<string, int> _info;

private:
	static InfoSingleton* _psins;	//定义成类里面的成员，就可以调用构造函数了，没有这一句外部定义不了全局的变量
	static mutex _smtx;
	static GC _gc;
};
InfoSingleton* InfoSingleton::_psins = nullptr;
mutex InfoSingleton::_smtx;
InfoSingleton::GC InfoSingleton::_gc;

int main()
{
	InfoSingleton::GetInstance().Insert("张三", 10000);
	InfoSingleton& infosl = InfoSingleton::GetInstance();
	infosl.Insert("李四", 15000);
	infosl.Insert("赵六", 12000);
	infosl.Insert("王五", 8000);
	infosl.Print();

	InfoSingleton::GetInstance().Insert("张三", 13000);
	InfoSingleton::GetInstance().Print();

	return 0;
}
相关推荐
郝学胜-神的一滴2 小时前
Linux网络编程中的connect函数：深入探索网络连接的基石
linux·服务器·网络·c++·websocket·程序人生
Cher ~2 小时前
常见C++编译器套件
开发语言·c++
CSDN_RTKLIB2 小时前
target_include_directories对比 PUBLIC / PRIVATE
c++
Titan20242 小时前
搜索二叉树笔记模拟实现
数据结构·c++·笔记·学习
LYOBOYI1232 小时前
qml的布局策略
c++·qt
sycmancia2 小时前
C++进阶02——C++和C中const的区别、三目运算符、引用的本质
c++
牙牙要健康2 小时前
【open3d】Windows 下编译 Open3D C++ 源码完整教程
开发语言·c++·windows
不染尘.2 小时前
二叉树相关题目
开发语言·数据结构·c++·算法
maplewen.3 小时前
C++11 std::mutex
开发语言·c++
热门推荐
01GitHub 镜像站点02Vue-skills的中文文档03Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services04Claude Code Skills 实用使用手册05一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示06UV安装并设置国内源07让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南08OpenClaw Chrome扩展使用教程 - 浏览器中继控制09Linux下V2Ray安装配置指南10AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南