【C++】特殊类的设计

2023-09-22 10:00:00

特殊类的设计

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

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

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

原因：

  1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
  2. 只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。
// 禁止拷贝的类
class copyban
{
private:
	copyban(const copyban& cb);
	const copyban& operator=(const copyban& cb);
};
  • C++11
    C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后跟上=delete，表示让编译器删除掉该默认成员函数。
// 禁止拷贝的类
class copyban
{
public:
	copyban(const copyban& cb) = delete;
	const copyban& operator=(const copyban& cb) = delete;
};

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

1、思路一：封锁构造函数

实现方式：

  1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
  2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

原因：
对象只能通过构造函数或者拷贝构造的方式进行创建，由于构造是私有的，类外不可以访问，如果想要创建对象只能调用这个静态成员函数，而静态成员函数里面创建的对象全都被我们设计在堆上了。

// 只能在堆上创建的对象
class HeapOnly
{
public:
	static HeapOnly* CreateObj(int x)
	{
		return new HeapOnly(x);
	}

	HeapOnly(const HeapOnly& ho) = delete;

private:
	HeapOnly(int x)
		:_x(x)
	{}

	int _x;
};

int main()
{
	//报错，
	//HeapOnly ho(1);
	
	// 正常运行
	HeapOnly* p =  HeapOnly::CreateObj(1);
}

2、思路二：封锁析构函数

实现方式：

  1. 将类的析构函数私有，使用new完成堆对象的创建。
  2. 提供一个公开的成员函数，用此公开的成员函数来析构对象。

原因：

  1. C++在栈上创建的对象析构时会隐式调用析构函数，由于析构函数是私有的，栈上如果创建了对象，就没有办法正常销毁。

  2. C++堆上的对象创建时不需要管析构函数，因为堆上的对象析构时要显示调用析构函数（不调用就会造成内存泄漏）

  3. 堆上的对象销毁时要调用析构函数，由于析构函数是私有的，为了完成资源清理，我们可以提供一个公开的成员函数，用此公开的成员函数来析构对象。

// 封锁析构
class HeapOnly
{
public:
	HeapOnly(int x)
		:_x(x)
	{}
	
	void Release()
	{
		delete this;
	}

private:
	~HeapOnly()
	{
		cout << "~HeapOnly()" << endl;
	}

	int _x;
};


int main()
{
	//报错，
	//HeapOnly ho(1);
	
	HeapOnly* ptr = new HeapOnly(1);
	ptr->Release();
}

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

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

class StackOnly
{
public:
	static StackOnly CreateObj(int x)
	{
		return StackOnly(x);
	}

	//禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
	// StackOnly obj = StackOnly::CreateObj(obj_1);
	void* operator new(size_t size) = delete;

private:
	StackOnly(int x)
		:_x(x)
	{}

	int _x;
};

int main()
{
	StackOnly so = StackOnly::CreateObj(1);
	// 报错
	//StackOnly* ptr = new StackOnly(so);
}

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

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

class NonInherit
{
public:
	static NonInherit GetInstance()
	{
	return NonInherit();
	}
private:
	NonInherit()
	{}
};
  • C++11方法
    final关键字，final修饰类，表示该类不能被继承。
class A final
{
	// ....
};

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

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

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

单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。

比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

1、单例模式的实现思路：

  1. 将构造函数设置为私有，并将拷贝构造函数和赋值运算符重载函数设置为私有或删除，防止外部创建或拷贝对象。
  2. 提供一个全局访问点获取单例对象。

两种实现模式：

  • 饿汉模式：不管你将来用不用，程序启动时就先创建一个唯一的实例对象。
class singleton
{
public:
	// 全局访问点
	static singleton* GetInstance()
	{
		return _psin;
	}

	void Add(const string& s)
	{
		_mtx.lock();
		_vstr.push_back(s);
		_mtx.unlock();
	}
private:
	// 禁止创建对象
	singleton()
	{}
	singleton(const singleton& sl) = delete;
	const singleton& operator=(const singleton& sl) = delete;

	mutex _mtx;
	//唯一对象的数据
	vector<string> _vstr;
	//指向唯一的对象
	static singleton* _psin;
};
// 得到唯一对象，在程序入口之前就完成单例对象的初始化
singleton* singleton::_psin = new singleton;

int main()
{
	singleton::GetInstance()->Add("main : " + to_string(1));
	int n = 100;

	singleton::GetInstance()->Print();
	cout << singleton::GetInstance()->Count() << endl;
	return 0;
}
  • 优点：简单
  • 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。

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

  • 懒汉模式，程序运行时需要使用单例对象时才实例对象

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

class singleton
{
public:
	static singleton* GetInstance()
	{
		// 双检查
		// 这一层用于提高效率
		if (_psin == nullptr)
		{
			_smtx.lock();
			// 这一层用于保证线程安全
			if (_psin == nullptr)
			{
				_psin = new singleton;
			}
			_smtx.unlock();
		}
		return _psin;
	}

	void Add(const string& s)
	{
		_mtx.lock();
		_vstr.push_back(s);
		_mtx.unlock();
	}

	static void DelInstance()
	{
		_smtx.lock();
		if (_psin)
		{
			delete _psin;
		}
		_smtx.unlock();
	}
	// 内部类 保证完成单例对象的回收
	struct GC
	{
		~GC()
		{
			DelInstance();
		}
	};
	// 当_gc对象销毁时自动调用析构函数。
	static GC _gc;

	~singleton()
	{
		// 一些持久化工作...这里就不再写出
		//...
		cout << "~singleton()" << endl;
	}
private:
	// 禁止创建对象
	singleton()
	{}
	singleton(const singleton& sl) = delete;
	const singleton& operator=(const singleton& sl) = delete;

	vector<string> _vstr;
	// 这把锁用来保护_vstr
	mutex _mtx;
	static singleton* _psin;
	// 这把锁用来保护 _psin
	static mutex _smtx;
};
// 初始化静态对象
singleton* singleton::_psin = nullptr;
mutex  singleton::_smtx;
singleton::GC singleton::_gc;

线程安全相关问题：

  • 懒汉模式是等到某个线程需要使用这个单例对象时再进行创建，也就是GetInstance函数第一次被调用时创建单例对象。
  • 在调用GetInstance函数获取单例对象时，需要先判断这个static指针是否为空，如果为空则说明这个单例对象还没有创建，此时需要先创建这个单例对象然后再将单例对象返回。
  • GetInstance函数第一次调用时需要对static指针进行写入操作，这个过程不是线程安全的，因为多个线程可能同时调用GetInstance函数，如果不对这个过程进行保护，此时这多个线程就会各自创建出一个对象。

懒汉模式还有一种比较经典的实现方式：

在单例类的GetInstance函数中定义一个静态的单例对象并返回，由于实际只有第一次调用GetInstance函数时才会定义这个静态的单例对象，这也就保证了全局只有这一个唯一实例。

class singleton
{
public:
	static singleton* GetInstance()
	{
		// 创建静态对象进行返回，利用static关键字的特性
		static singleton sing;
		return &sing;
	}

	void Add(const string& s)
	{
		_mtx.lock();
		_vstr.push_back(s);
		_mtx.unlock();
	}

	~singleton()
	{
		// 一些持久化工作...
		cout << "~singleton()" << endl;
	}
private:
	// 禁止创建对象
	singleton()
	{}
	singleton(const singleton& sl) = delete;
	const singleton& operator=(const singleton& sl) = delete;
	// 唯一对象的数据
	vector<string> _vstr;
	mutex _mtx;
	static singleton* _psin;
};
singleton* singleton::_psin = nullptr;

这种版本的懒汉模式的优点：

  • 实现起来比较简单，在实例化对象时不需要双检查，不需要写GC这样的类创建gc对象，也能够主动销毁对象。

缺点：

  • 单例对象定义在静态区，因此太大的单例对象不适合使用这种方式。
  • 单例对象创建在静态区后没办法主动释放。
  • 兼容性不是很好，C++98标准不保证多线程初始化static变量不会发生数据竞争，而C++11以后可以保证多线程初始化static变量不会发生数据竞争。

2、饿汉模式和懒汉模式对比

  • 饿汉模式
    优点：简单。

    缺点: 饿汉模式在程序运行主函数之前就会创建单例对象，如果单例类的构造函数中所做的工作比较多，就会导致程序迟迟无法进入主函数，在外部看来就好像是程序卡住了。
    此外，如果有多个单例类需要创建单例对象，并且它们之间的初始化存在某种依赖关系，比如单例对象A的创建必须在单例对象B之后，此时饿汉模式也会存在问题，因为我们无法保证这多个单例对象中的哪个对象先创建。

  • 懒汉模式
    优点：很好的解决上述饿汉模式的缺点，并且懒汉模式中各个单例对象创建的顺序是由各个单例类中的GetInstance函数第一次被调用的顺序决定，因此是可控制的。

    缺点: 在编码上比饿汉模式复杂，在创建单例对象时需要考虑线程安全的问题。

更多推荐

Excel_字母数字混合排序（数字不符合预期）的一种解决方法

引ADC_DCAL_DN1[13:0]ADC_DCAL_DN10[13:0]ADC_DCAL_DN11[13:0]ADC_DCAL_DN2[13:0]ADC_DCAL_DN3[13:0]ADC1_EOCADC10_EOCADC11_EOCADC2_EOCADC3_EOCADC4_EOCADC5_EOCADC_CALCB

酷开科技夯实流量基础，构建智慧生活新风尚！

在这个日新月异的时代，智能化趋势加速发展，依托于互联网服务的OTT也越来越贴近消费者的居家生活，并在家用场景下释放出独特的大屏营销价值。成立于2006年的酷开科技，一直是智能电视行业前进道路上的坚实力量，自创建以来便一直为互联网智能电视行业提供技术与运维服务。酷开科技以内容技术服务和数字营销服务为核心，自主研发了一套智

Leetcode.213 打家劫舍 II

题目链接Leetcode.213打家劫舍IImid题目描述你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金

Golang 的 GMP：并发编程的艺术

前言在Golang的并发编程中，GMP是一个重要的概念，它代表了Goroutine、M（线程）和P（调度器）。这个强大的三位一体的并发模型使得Golang在处理并发任务时非常高效和灵活。通过GMP的组合，Golang实现了一种高效的并发模型。它充分利用了多核处理器的优势，并通过轻量级的Goroutine实现了高并发的编

typescript 高级类型-class类详解

class简介typescript全面支持es2015中引入的class关键字,并为其添加了类型注解,和其它语法(比如,可见性修饰符等),class基本使用,如下tips1.根据ts中的类型推论,可以知道Person的实例对象p的类型是Person2.ts中的class,不仅提供了class的语法功能,也作为一种类型存

坚鹏：浙江农商联合银行同业核心产品解读与差异化分析培训第8期

浙江农商联合银行同业核心产品解读与差异化分析培训第8期1952年，浙江第一家农村信用社成立。2004年4月18日，浙江省农信联社成立，承担对全省农信社的管理、指导、协调和服务职能。2021年10月，经国务院批准同意、银保监会批复，浙江成为全国深化农信社改革“第一单”。2022年4月18日，省委书记袁家军，省委副书记、省

华清 Qt day1 9月15

.pro:QT+=coregui#引入QT所需要的核心库core，gui为图形开发相关类库greaterThan(QT_MAJOR_VERSION,4):QT+=widgets#表示如果超过4.0版本会自动加上widgets类库CONFIG+=c++11#表示支持C++11后的版本#Thefollowingdefine

SMS--短信服务

1短信服务介绍短信服务（ShortMessageService）是阿里云为用户提供的一种通信服务的能力。2短信服务使用接下来,我们使用短信验证码功能来演示短信服务的使用。流程如下:2.1准备工作2.1.1实名认证https://help.aliyun.com/document_detail/48263.html?spm

Algorithm基础算法学习

算法学习贪心算法贪心算法简介:这种算法模式一般将求解过程分成若干个步骤，但每个步骤都应用贪心原则，选取当前状态下最好/最优的选择（局部最有利的选择），并以此希望最后堆叠出的结果也是最好/最优的解。这就好像一个贪婪的人，他事事都想要眼前看到最好的那个，看不到长远的东西，也不为最终的结果和将来着想，贪图眼前局部的利益最大化

JMM内存模型

JMM概念JMM:JavaMemoryModel(JAVA内存模型)。是Java语言中用于定义多线程并发访问共享内存的规范。它规定了多线程环境下，如何保证共享内存的一致性和可见性，以及如何协调多个线程之间的操作。主内存和工作内存（本地内存）JMM将内存划分为主内存和每个线程的工作内存。主内存是所有线程共享的内存，而每个

二级配电箱智能监测系统

随着现代电力工业的发展，电力系统的复杂性和安全性要求日益提高。二级配电箱作为电力系统的重要环节，其运行状态直接影响到电力供应和电力系统的稳定性。因此，对二级配电箱进行智能监测显得尤为重要。本文将探讨如何实现二级配电箱的智能监测。一、配电箱智能监测系统架构力安科技通过在配电箱/柜场所安装“智慧供配电综合探测器”前端物联探

热文推荐
  1. 【Java 基础篇】Java同步方法解决数据安全

    多线程编程是现代应用程序开发中的常见需求，它可以提高程序的性能和响应能力。然而，多线程编程也带来了一个严重的问题：数据安全。在多线程环境下，多个线程同时访问和修改共享的数据可能导致数据不一致或损坏。为了解决这个问题，Java提供了一些机制来确保多线程之间的数据安全性，其中之一就是同步方法。本文将深入探讨Java同步方法

  2. pytorch张量数据类型

    python常用数据类型在pytorch中的对应pythonPyTorchIntIntTensorofsize()floatFloatTensorofsize()IntarrayIntTensorofsize[d1,d2,…]floatarrayFloatTensorofsize[d1,d2,…]string--pyt

  3. Java“对象”

    Java：PO、VO、BO、DO、DAO、DTO、POJOPO持久化对象（PersistentObject）PO是持久化对象，用于表示数据库中的实体或表的映射通常与数据库表的结构和字段对应PO的属性对应数据库表的字段，可以进行持久化操作（存储、读取、更新、删除）VO值对象（ValueObject）VO是值对象，用于封装

  4. 职业了解|03师范生的编制教师之路

    “初闻不解曲中意，再闻已是曲中人”。每个行业有一个共性在于，外面的人想进去，里面的人想出来。时代变化，不同的行业的细则也在变化。十五年前，有谁会预计计算机会这么火爆呢？估计大概率只会被认为计算机属于不务正业。而现在，宇宙的尽头是编制。但编制是否真的十全十美呢？本文讲述一个小学在编教师的心声。1、为什么想到读师范生我高考

  5. 基于CNN-LSTM的时序预测MATLAB实战

    一、算法原理1.1CNN原理卷积神经网络具有局部连接、权值共享和空间相关等特性。卷积神经网络结构包含卷积层、激活层和池化层。（a）二维卷积层将滑动卷积滤波器应用于输入。该层通过沿输入垂直和水平方向移动滤波器对输入进行卷积，并计算权重与输入的点积，然后加入一个偏置项。具体表达式为：卷积层的功能是对输入数据进行特征提取。其

  6. 基于R语言APSIM模型进阶应用与参数优化、批量模拟实践技术

    APSIM(AgriculturalProductionSystemssIMulator)模型是世界知名的作物生长模拟模型之一。APSIM模型有Classic和NextGeneration两个系列模型，能模拟几十种农作物、牧草和树木的土壤-植物-大气过程，被广泛应用于精细农业、水肥管理、气候变化、粮食安全、土壤碳周转、

  7. 1、MongoDb综述

    1.MongoDb综述1.1.什么是NosqlNoSQL：NotOnlySQL,本质也是一种数据库的技术，相对于传统数据库技术，它不会遵循一些约束，比如：sql标准、ACID属性，表结构等。Nosql优点l满足对数据库的高并发读写l对海量数据的高效存储和访问l对数据库高扩展性和高可用性l灵活的数据结构，满足数据结构不固

  8. zabbix

    zabbix是一个基于Web界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。zabbix能监视各种网络参数，保证服务器系统的安全运营；并提供灵活的通知机制以让系统管理员快速定位/解决存在的各种问题。zabbix由2部分构成，zabbixserver与可选组件zabbixagent。通过C/S模式采集数据

  9. sqlite条件查询语句where

    文章目录导入CSV数据where其他运算符sqlite初步导入CSV数据查询是数据库中最频繁的操作，但学习查询指令，最起码要有可供查询的表格。比如现在有下面这些2022排名前20的国家GDP的数据，当然格式是csv的，我们要做的第一步就是将其转为sqilte格式。1,美国,美洲,254600,0.2532042,中国,