C++进阶--特殊类设计

C++版本发展简史:新特性介绍 阅读详情

一、前言

   在C++类与对象中,C++98中,一个空类中编译器会默认生成六个成员函数,分别是构造函数、析构函数、拷贝构造函数、赋值运算符重载函数、普通对象和const对象取地址重载函数;在C++11中增加了移动构造和移动赋值。而对于一些特殊的类,当用户未显示生成相应的方法时,我们也不希望编译器生成该方法。所以每当设计一个类的时候都得根据用户的需求来进行相应的设计。

二、设计一个类,不能被拷贝

   一个类中会发生拷贝构造的情景有:拷贝构造函数和赋值运算符重载。要使一个类中不可发生拷贝,则只需让该类中的拷贝构造函数和赋值运算符重载不可被调用即可。

2.1 C++98方式

  • 将拷贝构造函数与赋值运算符重载函数只声明而不进行定义,且将其访问权限设置为私有。
  • 设置私有的原因:如果只声明没有设置成private,用户自己如果在类外定义了,就不能禁止拷贝了。
  • 只声明不定义:不定义是因为该函数根本不会调用,定义了其实也没有什么意义,不写反而还简单,而且如果定义了就不会防止成员函数内部拷贝了。
class CopyBan
{
	// ...
private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);
	//...
};

2.2 C++11方式

  • C++扩展delete的用法,delete除了释放new申请的资源外,如果在默认成员函数后跟上=delete,表示让编译器删除掉该默认成员函数。
class CopyBan
{
	// ...
	CopyBan(const CopyBan&)=delete;
	CopyBan& operator=(const CopyBan&)=delete;
	//...
};

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

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

为什么要是静态的成员函数?

  • 类的普通成员函数需要对象去调用,而静态的成员函数可以通过类域访问,不需要通过对象访问。
//思路1:C++98
class HeapOnly
{
public:
	void Destroy()
	{
		delete this;
	}

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

	int _x;
};

int main()
{
	/*HeapOnly ho1;
	static HeapOnly ho2;*/

	HeapOnly* pho3 = new HeapOnly;
	pho3->Destroy();

	return 0;
}
//思路2:C++11
class HeapOnly
{
public:
	static HeapOnly* CreateObj(int x = 0)
	{
		HeapOnly* p = new HeapOnly(x);
		return p;
	}

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

	HeapOnly(const HeapOnly& hp) = delete; // = delete来明确表示该函数被禁用(不允许调用该函数,调用就会报错)
	HeapOnly& operator=(const HeapOnly& hp) = delete;

	int _x;
};


int main()
{
	/*HeapOnly ho1;
	static HeapOnly ho2;

	HeapOnly* pho3 = new HeapOnly;*/

	HeapOnly* p1=HeapOnly::CreateObj(1);
	//HeapOnly p2(*p1);

	return 0;
}

注意:上面存在一个小小的细节需要我们注意的

HeapOnly* p1=HeapOnly::CreateObj(1);
HeapOnly p2(*p1);

   使用p1指针的内容拷贝构造对象,此时拷贝的对象是在栈上的,所以我们也要把拷贝构造函数搞成私有或者delete掉
说明:

  • 将拷贝构造函数设置为私有,并且只声明不实现,防止外部调用拷贝构造函数在栈上创建对象。
  • 向外部提供的CreateObj函数必须设置为静态成员函数,因为外部调用该接口就是为了获取对象的,而非静态成员函数必须通过对象才能调用,这就变成鸡生蛋蛋生鸡的问题了。
  • C++98通过将拷贝构造函数声明为私有以达到防拷贝的目的,C++11可以在拷贝构造函数后面加上**=delete**,表示让编译器将拷贝构造函数删除,此时也能达到防拷贝的目的。

四、设计一个类,只能在栈上创建对象

   将构造函数私有化,然后设计静态方法创建对象返回即可(返回匿名对象)

1.将构造函数设置为私有,防止外部直接调用构造函数在堆上创建对象。
2.向外部提供一个获取对象的static接口,该接口在栈上创建一个对象并返回。

class StackOnly
{
public:
    //提供一个获取对象的接口,并且该接口必须设置为静态成员函数
	static StackOnly CreatorObj()
	{
		return StackOnly();//返回匿名对象
	}
private:
	StackOnly()
		:_a(0)
	{}

	int _a;
};

   上面的代码同样有Bug,我们仍然可以创建不在栈上的对象:无法防止外部调用拷贝构造函数创建对象。

class StackOnly
{
public:
	static StackOnly CreatorObj()
	{
		return StackOnly();//返回匿名对象
	}
private:
	StackOnly()
		:_a(0)
	{}

	int _a;
};
int main()
{
	StackOnly obj = StackOnly::CreatorObj();//在静态区拷贝构造对象
	StackOnly* ptr = new StackOnly(obj); //此时调用的是拷贝构造去new一个对象, ptr指向的对象在堆上创建, -在堆上拷贝构造对象
	return 0;
}

所以该如何解决呢?能不能按照上面的方法,把拷贝构造函数写成私有或者delete呢?

   但是我们不能将构造函数设置为私有,也不能用=delete的方式将拷贝构造函数删除,因为CreatorObj函数返回的时候是传值返回,要拷贝构造一个临时对象返回。
   既然拷贝构造函数不能封死,那就封死new吧,让用户无法使用new

方法:屏蔽new

   因为new在底层调用void* operator new(size_t size)函数,一个类可以重载它专属的operator new,如果没有专属的operator new,new一个对象时就去调用全局的。如果一个类重载了operator new,通过new创建该类对象时,就去调用专属的operator new。

new和delete的原理:

  • new在堆上申请空间实际分为两步:第一步是调用operator new函数申请空间,第二步是在申请的空间上执行构造函数,完成对象的初始化工作。
  • delete在释放堆空间也分为两步,第一步是在该空间上执行析构函数,完成对象中资源的清理工作,第二步是调用operator delete函数释放对象的空间。

new和delete默认调用的是全局的operator new函数和operator delete函数,但如果一个类重载了专属的operator new函数和operator delete函数,那么new和delete就会调用这个专属的函数。所以只要把operator new函数和operator delete函数屏蔽掉,那么就无法再使用new在堆上创建对象了。

class StackOnly
{
public:
	static StackOnly CreatorObj()
	{
		return StackOnly();//返回匿名对象
	}
	//C++11的方式
	void* operator new(size_t size) = delete;  // = delete来明确表示该函数被禁用(不允许调用该函数,调用就会报错)
	void operator delete(void* p) = delete;
private:
	//C++98的方式:私有化
	//void* operator new(size_t size){}
	//void operator delete(void* p) {}
	StackOnly()
		:_a(0)
	{}

	int _a;
};

五、设计一个类,不能被继承

5.1 C++98方式

   将父类的构造函数私有化,子类对象创建的时候,需要先调用父类的构造函数初始化父类的部分,然后再调用子类的构造函数初始化,但父类的私有成员在子类当中是不可见的,所以在创建子类对象时子类无法调用父类的构造函数对父类的成员进行初始化,因此该类被继承后子类无法创建出对象,这样做了之后派生类中调不到基类的构造函数,则无法实现继承。

class Base
{
private:
	Base()
		:_a(0)
	{}

	int _a;
};

5.2 C++11方式

   C++98的这种方式其实不够彻底,因为这个类仍然可以被继承(编译器不会报错),只不过被继承后无法实例化出对象而已。于是C++11中提供了final关键字,被final修饰的类叫做最终类,最终类无法被继承,此时就算继承后没有创建对象也会编译出错。
   final关键字:final修饰类,表示该类不能被继承

class Base final	//子类继承的时候就会报错了:不能将final类类型用作基类
{
private:
	Base()
		:_a(0)
	{}

	int _a;
};

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

设计模式:
设计模式是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。目的是为了代码重用性、让代码更容易被他人理解、保证代码可靠性。 其中单例模式、工厂模式、观察者模式使用得比较多

单例模式:
单例模式是设计模式当中的一种,单例模式即一个类只能创建一个对象,保证系统中该类只有一个实例,并提供一个访问它的全局访问点,该实例被所有程序模块所共享。

单例模式的两种实现模式:饿汉模式和懒汉模式

6.1 饿汉模式

不管将来用不用,程序启动时就创建一个唯一的实例对象

单例模式的饿汉实现方式如下:

1.将构造函数设置为私有,并将拷贝构造函数和赋值运算符重载函数设置为私有或删除,防止外部创建或拷贝对象。
2.提供一个全局的static单例对象,并在程序入口之前完成单例对象的初始化。
3.提供一个静态函数用于获取单例对象。

//饿汉模式:一开始(main函数之前)就创建对象    //(全局对象可以在main函数之前创建好)
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return _ins;
	}

	void Add(const string& str)
	{
		_mtx.lock();

		_v.push_back(str);
		/*++_n;*/

		_mtx.unlock();
	}

	void Print()
	{
		_mtx.lock();

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

		_mtx.unlock();
	}

private:
	//限制类外面随意创建对象
	Singleton()
	{}
 
 //防拷贝
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;

private:
	mutex _mtx;
	/*int _n = 0;*/
	vector<string> _v;

	static Singleton* _ins;
};

Singleton* Singleton::_ins = new Singleton;

饿汉模式的优缺点:
优点:简单
缺点:可能会导致进程启动慢,且如果有多个单例类对象实例启动顺序不确定

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

6.2 懒汉模式

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

单例模式的懒汉实现方式如下:

1.将构造函数设置为私有,并将拷贝构造函数和赋值运算符重载函数设置为私有或删除,防止外部创建或拷贝对象。
2.提供一个指向单例对象的static指针,并在程序入口之前先将其初始化为空。
3.提供一个全局访问点获取单例对象。

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		//双检查加锁
		if (_ins == nullptr)        //提高效率,不需要每次获取单例都加锁解锁
		{
			_imtx.lock();

			if (_ins == nullptr)     //保证线程安全和只new一次
			{
				_ins = new Singleton;
			}
			_imtx.unlock();
		}
		return _ins;
	}

	//一般全局都要使用单例对象,所以单例对象一般不需要显示释放
	//有些特殊场景,想显示释放一下
	static void DelInstance()
	{
		_imtx.lock();
		if (_ins)
		{
			delete _ins;
			_ins = nullptr;
		}
		_imtx.unlock();
	}

	//内部类:单例对象回收
	class GC
	{
	public:
		~GC()
		{
			DelInstance();
		}
	};

	static GC _gc;


	void Add(const string& str)
	{
		_vmtx.lock();

		_v.push_back(str);
		/*++_n;*/

		_vmtx.unlock();
	}

	void Print()
	{
		_vmtx.lock();

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

		_vmtx.unlock();
	}

	~Singleton()
	{
		//持久化
		//比如要求程序结束时,将数据写到文件,单例对象析构时持久化就比较好

	}

private:
	//限制类外面随意创建对象
	Singleton()
	{}

	//防拷贝
	Singleton(const Singleton& s) = delete;
	Singleton& operator=(const Singleton& s) = delete;

private:
	mutex _vmtx;
	/*int _n = 0;*/
	vector<string> _v;

	static Singleton* _ins;
	static mutex _imtx;
};

Singleton* Singleton::_ins = nullptr;
mutex Singleton::_imtx;

Singleton::GC Singleton::_gc;

int main()
{
	///*Singleton s1;
	//static Singleton s2;*/

	//Singleton::GetInstance()->Add("张三");
	//Singleton::GetInstance()->Add("李四");
	//Singleton::GetInstance()->Add("王五");

	//Singleton::GetInstance()->Print();

	srand(time(0));

	int n = 30;
	thread t1([n]() {
		for (size_t i = 0; i < n; ++i)
		{
			Singleton::GetInstance()->Add("t1线程:" + to_string(rand()));
		}
		});

	thread t2([n]() {
		for (size_t i = 0; i < n; ++i)
		{
			Singleton::GetInstance()->Add("t2线程:" + to_string(rand()));
		}
		});

	t1.join();
	t2.join();

	Singleton::GetInstance()->Print();

	Singleton::GetInstance();

	//Singleton s(*Singleton::GetInstance());

	return 0;
}

双检查枷锁:

  • 对GetInstance函数中创建单例对象的过程进行保护,本质就是需要引入互斥锁,最简单的加锁方式就是在进行if判断之前加锁,在整个if语句之后进行解锁,当然也可以使用unique_lock进行加锁
  • 但实际只有GetInstance函数第一次被调用,创建单例对象时需要使用互斥锁进行保护,而后续调用GetInstance函数获取单例对象只是一个读操作,是不需要使用互斥锁进行保护的。
  • 如果简单的将加锁解锁操作放到if语句前后,那么在后续调用GetInstance函数获取已经创建好的单例对象时,就会进行大量无意义的加锁解锁操作,导致线程不断切入切出,进而影响程序运行效率。
  • 对于这种只有第一次需要加锁保护的场景可以使用双检查加锁,双检查就是在当前加锁和解锁的外面再进行一次if判断,判断static指针是否为空。
  • 这样一来,后续调用GetInstance函数获取已经创建好的单例对象时,外层新加的if判断就会起作用,这样就避免了后续无意义的加锁解锁操作。

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

6.3 饿汉模式和懒汉模式对比

饿汉模式:
优点:简单,提前准备好单例对象
缺点1:无法控制单例创建初始化顺序

  • 如果有多个单例类需要创建单例对象,并且它们之间的初始化存在某种依赖关系,比如单例对象A的创建必须在单例对象B之后,此时饿汉模式也会存在问题,因为我们无法保证这多个单例对象中的哪个对象先创建

缺点2:因为饿汉模式在程序运行主函数之前就会创建对象,如果单例类的构造函数中所做的工作比较多,就会导致程序迟迟无法进入主函数,在外部看来就好像是程序卡住了。

懒汉模式:
优点:解决上述饿汉模式的缺点

  • 因为懒汉模式并不是一开始就完成单例对象的创建,因此不会导致程序迟迟无法进入主函数。
  • 并且懒汉模式中各个单例对象创建的顺序是由各个单例类中的GetInstance函数第一次被调用的顺序决定,因此是可控的。

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

【C/C++】C++98基础上的C++11新特性 一、新语法 1.自动类型推导auto auto的自动推导,用于从初始化表达式中推断出变量的数据类型。 //C++98 int a = 10; string s = "abc"; float b = 10.0; vector&lt;int&gt; c; vector&lt;vector&lt;int&gt; &gt; d; map&lt;int, string&gt; m; m[1] = "... 阅读详情

相关推荐

C++98与C++14:时代变迁下的编程语言进化

在编程世界中,C++无疑是一种强大且流行的语言。自其诞生以来,C++已经经历了多个版本的迭代和更新,其中C++98和C++14是两个具有里程碑意义的版本。本文将详细介绍这两个版本之间的区别,帮助读者更好地理解C++语言的进化历程。

笔者从事电信媒体开发多年,愿意将多年的开发经验分享给同行 1990

C++98和C++11的特性和改进

需要注意的是,相较于 C++11、C++14 和 C++17,C++98 的新特性相对较少,C++11 引入的新特性更加丰富和强大。类型推断:C++11 引入了 decltype 关键字和更加灵活的模板类型推导规则,提高了 C++ 中类型推断的能力。新的标准库组件:C++11 引入了新的标准库组件,如正则表达式库、元组库、随机数库等,增强了 C++ 标准库的功能。总的来说,C++11 相较于 C++98 引入了许多重要的新特性和改进,使得 C++ 编程更加方便、灵活和高效,提高了代码的质量和效率。

m0_60352504的博客 1835

C#国产化技术路线(全栈落地指南,适配信创场景)

本文详细介绍了C#语言在信创产业中的国产化适配方案。核心方案基于.NET8框架,通过硬件架构适配、基础软件替换和打包部署优化三个层面进行改造,无需更换开发语言即可适配国产CPU和操作系统。文章系统讲解了开发工具选择、全栈适配层改造、数据库替换等技术要点,并提供了桌面应用和服务端应用的具体开发流程。针对政务、金融、能源等典型场景给出了可直接套用的技术组合,同时总结了10个关键避坑点。该方案可复用C#开发特性,实现低成本迁移,已在多个行业成功落地。

weilinc的专栏 1216

C++发展历史C++98和C++11详细介绍

C++发展历史C++98和C++11详细介绍

weixin_38834817的博客 2040

Pointnet++环境配置+复现

深度学习点云经典网络Pointnet++

weixin_58663121的博客 8080

YOLO模型使用jupyterlab的方式进行预测/推理(示例)

首先相信很多使用过python的人都或多或少地了解过这个应用。是一个开源Web应用程序,可让用户创建和共享包含实时代码、公式、可视化和叙述文本的文档。用途包括:数据清理和转换、数值模拟、统计建模、等等。而Jupyter Lab则是Jupyter的下一代笔记本界面。是一个基于Web的交互式开发环境,用于Jupyter notebook、代码和数据。非常灵活,可支持数据科学、科学计算和机器学习领域的广泛工作。是可扩展和模块化的,其可编写插件来添加新组件并与现有组件相集成。

ocean00008899的博客 904

[cpp进阶]C++特殊类设计

为什么会产生设计模式这样的东西呢?就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期,七国之间经常打仗,就发现打仗也是有套路的,后来孙子就总结出了《孙子兵法》。孙子兵法也是类似。

weixin_53027918的博客 961

Axure RP 9在Windows 11环境下的高效安装与配置指南

本文提供Axure RP 9在Windows 11系统下的详细安装步骤与配置指南。针对Win11安全特性,从获取官方安装资源、调整系统权限,到定制化安装路径、精准汉化及性能优化,系统性地解决了安装闪退、汉化失败、运行卡顿等常见问题,确保用户获得稳定流畅的原型设计体验。

mango的博客 485

C++进阶—特殊类设计

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

Awkwardx的博客 569

腾讯滑块验证码collect参数逆向与JSVMP对抗实战

本文深入解析腾讯滑块验证码collect参数的逆向过程与JSVMP虚拟机对抗技术。通过详细的环境搭建、抓包分析和JSVMP逆向技巧,揭示collect参数的生成逻辑与加密流程,并提供完整的模拟实现方案和常见问题排查方法,助力开发者突破腾讯天御验证码的防护机制。

weixin_29009501的博客 1595

【UE5_蓝图】实时音频采集与动态WAV文件保存实战指南

本文详细介绍了在UE5中使用蓝图实现实时音频采集与动态WAV文件保存的完整流程。从插件配置、录音框架搭建到动态文件名生成和音频参数优化,提供了实用技巧和常见问题解决方案,特别适合需要快速实现音频采集功能的开发者。

weixin_29009669的博客 413

C++进阶 特殊类的设计

介绍C++中几种特殊类的设计以及单例模式

小萌新的博客 1105

Vivado2019.1 ZYNQ7020无Uart SDK调试打印调试信息xil_printf

Vivado2019.1 ZYNQ7020无Uart SDK调试打印调试信息xil_printf

泛红尘的博客 3001

c++进阶之——特殊类设计

了,就可以。

2201_75453663的博客 1026

iOS面试题大全(附带答案)

C语言相关面试题 1.static有什么用途? 答案:在C语言中,static主要定义全局静态变量,定义局部静态变量,定义静态函数。 static 属于静态变量,使用它修饰的变量生命周期是整个源程序。 @1.在函数体内的 static 变量的作用范围为该函数体,该变量的内存只被分配一次,因此其值在下次调用时仍维持上次的值; @2.在模块内的 static 全局变量可以被模块内所有函数访问,但不能被模块外其它函数访问; @3.在模块内的 static 函数只被这一模块内的其它函数调用,这个函数的使用范围被限

IOSNF的博客 2430

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

【C++进阶】特殊类设计

C++特殊类设计详解

m0_60338933的博客 1263

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

C++进阶-特殊类设计

拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝,。C++98将,delete除了释放new申请的资源外,如果在默认成员函数后跟上=delete,。

weixin_64423718的博客 680

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

【C++进阶】特殊类的设计——单例模式详解

特殊类的设计我们只要知道常用的就可以了,单例模式还是比较的常用,所以要好好理解一下。下一节我们会带来C++的收尾内容,到这里我们C++的主要内容也快结束了,但是继续深挖C++的话还是有很多东西要学,所以希望大家可以持续学习,我也会带来更多的内容去分享。

weixin_64906519的博客 1056

C++进阶 — 特殊类设计

使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样。比如迭代器模式,配接器(适配器)模式,单例模式,工厂模式,观察者模式等。这些都是设计模式。

一个努力拼搏的人 901

C++进阶篇,特殊类设计

C++的一些特殊类,重点介绍了单例模式。

CHAKMING1的博客 1160

C++进阶(十六)特殊类设计

分享c++特殊类设计的知识。

2301_78995005的博客 1443

【C++进阶学习】第十四弹——特殊类设计——探寻各种情况下类的应用

【C++进阶学习】第十四弹——特殊类的设计:探索特殊条件下类的设计方式,加深对类的理解和应用

2301_80220607的博客 3976

【C++进阶】特殊类设计 && 单例模式

上述写法C++11之前不能用,局部静态单例对象构造初始化无法保证线程安全问题,C++11后可以用,C++11之后进行了优化,就不会出现线程安全的问题了!初始化网络连接啊,读取文件啊等等,而有可能该对象程序运行时不会用到,那么也要在程序一开始就进行初始化,就会导致程序启动时非常的缓慢。C++98中构造函数私有化,派生类中调不到基类的构造函数。final关键字,final修饰类,表示该类不能被继承。但是上述代码又会带来新的问题,假如是在多线程情况下跑呢?C++11就直接删除该默认成员函数!

2301_78611726的博客 607

C++进阶(9)特殊类设计

特殊类的设计

2301_79907403的博客 739

[c++进阶(三)]单例模式及特殊类的设计

特殊类的设计和单例模式就讲到这了,只单说概念其实大家对于单例模式的强大性还是理解的不够深刻,只有在结合项目一起使用时,那么理解就会快速增加了。拓展:单例模式只是设计模式中的一种,还有工厂模式,适配器模式等等,有想了解这些设计模式的可以自行查阅资料。设计模式 - 概览 | C++ 全栈知识体系 (stibel.icu)

weixin_62196764的博客 1160
上一篇: C++进阶--哈希的应用之位图和布隆过滤器
下一篇: C++进阶--C++11入门基础
sushang~
博客等级 码龄5年 1298粉丝 141原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址