【C++】特殊类设计

最新推荐文章于 2024-05-11 18:41:21 发布
最新推荐文章于 2024-05-11 18:41:21 发布
阅读量1.1k 收藏 16
点赞数 25
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73898917/article/details/135631269
版权

Content

0. 设计一个类，不能实例化出对象

C++98写法

  • 将类的构造函数声明为private，只能通过调用一个静态成员函数（通常称为create或getInstance等）来获取类的实例。
// C++98
class NoInstance98 
{
private:
    NoInstance98() {}

public:
    static NoInstance98* create() 
    {
        return new NoInstance98();
    }
};

int main()
{
    // C++98
    auto obj98 = NoInstance98::create();
    delete obj98;
    return 0;
}

C++11写法

  • 在C++11及以后的版本中，可以使用纯虚函数（pure virtual function）来使类成为抽象类，从而无法被实例化。纯虚函数可以通过在声明时使用= 0来标记。
// C++11
class NoInstance11 
{
public:
    virtual void doSomething() = 0;
};

class Derived : public NoInstance11 
{
public:
    void doSomething() override {}
};

int main() 
{
    // C++11
	NoInstance11 obj11;  // 报错，无法直接实例化抽象类
    Derived objDerived;
    objDerived.doSomething();
	
    return 0;
}

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

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

C++98写法

  • 将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
class CopyBan
{
	// ...
private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);
	//...
};
  • 如果尝试调用，会造成编译错误：
#include <iostream>
#include <map>
#include <string>
#include <utility>
using namespace std;

class CopyBan
{
public:
    CopyBan() {}
private:
    CopyBan(const CopyBan&);
    CopyBan& operator=(const CopyBan&);
};


int main() 
{
    CopyBan obj1;
    // 尝试复制构造
    CopyBan obj2 = obj1;  // 编译错误:"CopyBan::CopyBan(const CopyBan &)" 不可访问

    // 尝试赋值
    CopyBan obj3;
    obj3 = obj1;  // 编译错误:"CopyBan &CopyBan::operator=(const CopyBan &)" 不可访问	
	
    return 0;
}

[!reasons] 两个原因

  1. 设置成私有的原因：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
  2. 只声明不定义的原因：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11写法

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

默认构造函数私有化或删除的意义

上面讲了拷贝构造函数和赋值运算符重载的私有化或删除来避免对象拷贝和赋值，那么将默认构造函数私有化或删除的意义是什么呢？

在C++中，私有化默认无参数的构造函数的主要目的是限制对象的默认实例化。当一个类的构造函数被私有化，意味着外部代码无法直接调用该构造函数创建类的对象。这样做的一些常见目的包括：

  1. 单例模式（Singleton Pattern）： 通过私有化构造函数，可以确保一个类的实例只能在类内部被创建，从而实现单例模式。单例模式保证一个类只有一个实例，并提供全局访问点。
class Singleton 
{
private:
	Singleton() {} // 私有构造函数
public:
	static Singleton& getInstance() 
	{
		static Singleton instance; // 只有在类内部可以调用构造函数
		return instance;
	}
};
  1. 工厂模式（Factory Pattern）： 通过私有化构造函数，可以强制使用类内的工厂方法来创建对象，从而对对象的创建过程进行更严格的控制。
class MyClass 
{
private:
	MyClass() {} // 私有构造函数

public:
	static MyClass createInstance() 
	{
		return MyClass(); // 可以在工厂方法中调用私有构造函数
	}
};
  1. 防止对象创建和初始化的滥用： 有时候，类的默认构造函数可能执行一些特殊的初始化操作，或者需要在创建对象时进行一些额外的逻辑。私有化构造函数可以防止外部代码滥用默认构造函数，确保对象在被创建时经过类内部的逻辑。

私有化默认无参数的构造函数是一种对类的实例化过程进行控制的手段，用于确保对象的创建和初始化按照类设计者的意图进行。

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

  • 实现方式：
    1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
    2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly; //在HeapOnly的类作用域里可以调到private的构造函数
	}
private:
	HeapOnly() {}
	
	// C++98
	//  1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
	//  2.声明成私有
	HeapOnly(const HeapOnly&);
	
	// C++11
	HeapOnly(const HeapOnly&) = delete;
};

int main()
{
	HeapOnly* hp = new HeapOnly; // 编译错误，因为new创建对象也要调用构造函数的，但是你已经私有化构造函数了
	return 0;
}

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

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

但是这里就不能禁用拷贝构造了，因为在返回的时候肯定是返回一个局部对象，所以 CreateObject 只能传值返回，但是只要是传值返回就肯定是要拷贝构造，那么如果把拷贝构造禁用了，那么返回的时候就会有问题

class StackOnly
{
public:
	static StackOnly CreateObject()
	{
		return StackOnly();
	}
private:
	StackOnly()
	{}
};

方法二：屏蔽new和delete

class StackOnly
{
public:
	StackOnly() {}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};
 
int main()
{
	StackOnly so;
	StackOnly* p = new StackOnly;
	 
	static StackOnly sso;
	return 0;
}

请添加图片描述

也可以用 C++11 的 = delete 去实现

void* operator new(size_t size) = delete;
void operator delete(void* p) = delete;

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

C++98写法

  1. C++98中构造函数私有化，派生类中调不到基类的构造函数。则无法继承
  2. 无法继承的原因是父类私有成员在子类类作用域中不可见
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

请添加图片描述

C++11写法

  • final关键字：用final修饰类，表示该类不能被继承
class A final
{
	// ...
};

请添加图片描述

5. 设计一个类，只能实例化一个对象（单例模式）

在讲单例模式之前，先讲讲什么是类的设计模式：

  1. 设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结
  2. 为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵法》
  3. 使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样
  4. 设计模式分为三大类：创建型模式、结构型模式、行为型模式
    • 创建型模式(5种)：工厂方法、抽象工厂方法、单例模式、建造者模式、原型模式
    • 结构型模式(8种)：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
    • 行为型模式(13种)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

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

1. 饿汉单例模式

饿汉单例模式：就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

  • 可以在类中存放静态对象的指针，并立即在类外初始化：
// 饿汉模式
// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
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 = new Singleton; 
 
int main()
{
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	return 0;
}
  • 也可以在类中直接存放静态对象：
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
	
	void Add(const string& key, const string& value)
	{
		_dict[key] = value;
	}
	
	void Print()
	{
		for (auto& kv : _dict)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}
	
private:
	// 构造函数私有
	Singleton()
	{};
	
	// C++11写法
	Singleton(Singleton const&) = delete;
	Singleton& operator=(Singleton const&) = delete;
	
	map<string, string> _dict;
	int _n = 0;
	
	static Singleton m_instance;
};

// 静态成员变量必须在类外进行定义。
// 这是因为静态成员变量不属于任何类的对象或实例，
// 它们是类的一部分。在类外定义静态成员变量可以为其分配内存。
// 如果不在类外定义，编译器就不会为其分配内存，从而导致链接错误。
Singleton Singleton::m_instance;

int main()
{
	Singleton::GetInstance()->Add("hello", "你好");
	Singleton::GetInstance()->Add("sort", "排序");
	Singleton::GetInstance()->Add("patience", "耐心");
	Singleton::GetInstance()->Print();
	cout << (void*)Singleton::GetInstance() << endl;
	cout << (void*)Singleton::GetInstance() << endl;
	cout << (void*)Singleton::GetInstance() << endl;
	return 0;
}

请添加图片描述

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

  1. 饿汉单例模式优点：
    • 保证全局（整个进程）只有唯一实例对象
    • 饿汉模式：一开始就创建对象，特别简单
  2. 饿汉单列模式缺点：
    • 多个单例对象A,B,C假设要求他们之间有依赖关系：依次创建,就无法达到，无法保证顺序
    • 可能会导致程序启动很慢

2. 懒汉单例模式（待续）

// 懒汉
// 优点：第一次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序自由控制。
// 缺点：复杂
#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;
void func(int n)
{
	cout << Singleton::GetInstance() << endl;
}

// 多线程环境下才能演示上面GetInstance()加锁和不加锁的区别
int main()
{
	thread t1(func, 10);
	thread t2(func, 10);
	t1.join();
	t2.join();
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
}
_宁清
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
C++特殊类设计
ketil27的博客
01-26 3238
为了代码可重用性、让代码更容易被他人理解、保证代码可靠性；设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
C++ 特殊类设计
修行的凡人的博客
11-15 3029
基于著名书籍和自我学习得出的C++特殊类设计精华知识
c++类和对象
includeevey的博客
10-06 7154
全文将讲解《类和对象》，文章比较长，请慢慢观看！
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 59万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
C++语言程序设计
qq_51427542的博客
11-01 2918
第四章 类与对象 一、面向对象程序设计的基本特点 1.抽象：对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述的过程。 一个问题的抽象分为两方面：数据抽象<描述某类对象的属性和状态>和行为抽象<描述某类对象的共同行为或功能特征>。（或称功能抽象和代码抽象）。 eg：时钟程序：用三个整型来存储时分秒——数据抽象 int hour,int minute,int second 时钟具有显示时间，设置时间的功能——行为抽象 showTime(),setTime() 2.封装：将抽象
C++ 常见设计模式总结
qq_41952309的博客
08-22 1660
c++ 常见设计模式整理。
c++ 派生类
weixin_42123332的博客
04-06 6682
1.派生类是对类的具体化，而类是派生类的抽象。 2.派生类的声明方式：class 派生类名 继承方式 基类名。 3.派生类的继承方式有protected private public。 4.公用继承的介绍： 代码示例如下： #include<iostream> #include<string> using namespace std; class Student//声明基类 { public: void get_1()//输入姓名及性别 { cin
C++ —— 类的声明
柚咖小窝
03-08 6800
自定义类型 1. 定义类型需要做什么 在自定义类型之前，需要了解定义类型都需要做什么。C++ 的基本数据类型完成了三项工作： 决定数据对象需要的内存数量； 决定如何解释内存中的位； 决定如何使用数据对象执行的操作或方法。 对于内置类型来说，有关操作被内置到编译器中。例如，整型可以进行 % 运算，而浮点型不可以。 2. C 和 C++ 自定义类型的演示 在 C++ 中定义用户自定义的类型时，就必须自己提供操作自定义类型的方法。付出这些劳动换来了根据实际需要定制新数据类型的强大功能和灵活性。例如，自定义一个
接口 抽象类 C++
生活需要深度
01-09 3229
2. Hello World #include <iostream> using namespace std; int main() { cout << "Hello, world!" << endl; return 0; }
c++课程设计 学生选课系统
04-07
针对学生选课这一环节,本系统从管理员对学生、教师、课程信息管理以及学生自主选课退课两个大方面进行了设计,基本实现了学生的课程信息查询、选课退课功能以及教师对选该自己课程的学生信息查看等功能,实现全校学生...
c++课程设计
05-22
包含多个南理工c++课程设计工程。包括扑克牌、五子棋、福彩游戏、对抗游戏、计算器、分数计数器、八皇后、方程求解、字符串操作、矩阵旋转、物品库存管理、股票交易、电话本，特殊图像效果。
visual c++特殊界面设计
03-21
visual c++特殊界面设计 仪表界面设计
操作系统课程设计——Linux二级文件系统设计-C++文档类资源
04-11
使用文件来模拟外存，进行数据结构设计和操作算法的设计，实现一个文件系统并实现基本的文件操作（为了简便文件系统，不考虑文件共享，文件系统安全以及管道文件与设备文件等特殊内容）。要求： 1、对程序的每一...
《C++算法程序设计》
09-03
现在我们将要开始一个穿越“数据结构、算法和程序”这个抽象世界的特殊旅程， 以解决现实生活中的许多难题。在程序开发过程中通常需要做到如下两点：一是高效地描述数 据；二是设计一个好的算法，该算法最终可用程序...
c++父类指针指向子类
最新发布
qq_43700779的博客
05-11 103
父类指针指向子类，调用的函数是谁的
初识C语言——第十四天
硬件菜鸟的成长之路
05-07 689
【代码】初识C语言——第十四天。
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 86
UE5 C++ 的FString类型取值问题。
webassembly入门详解（C++）
啊渊的专栏
05-05 1024
webassembly C++ windows下开发环境搭建。
c++常用的设计模式
09-12
装饰器模式是一种结构型设计模式，允许你通过将对象放入包含行为的特殊封装对象中来为原对象动态添加新的行为。通过使用装饰器模式，可以在不修改原有对象的情况下，灵活地扩展其功能。 工厂模式是一种创建型设计...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_宁清

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值