C++特殊类的设计与单例模式

C&C++ HJfjfK
前端之家收集整理的这篇文章主要介绍了C++特殊类的设计与单例模式，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

#pragma once


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

C++98;
将拷贝构造函数与赋值运算符重载只声明不定义，并且将其访问权限设置为私有即可。
原因：
1. 设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了
2. 只声明不定义：防止编译器自动生成,且没必要定义,原本就是不想使用

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

h*/


//2.设计一个只能在堆上创建对象的类
//------------------------------------------------------------ 只能在堆上创建对象的类
/*
//思路1:隐藏析构函数
class HeapOnly
{
public:

void Destory()
{
delete this;
}

private:
~HeapOnly()
{
std::cout << "~HeapOnly()" << std::endl;
}
//public:
int _x;
};

int main()
{

//HeapOnly ho1; //报错,没有可访问的析构函数类不能在栈上定义对象,因为栈上的对象是由编译器负责析构的,但类外不能访问私有,即编译器调不到析构,释放不了,所以会有问题
//HeapOnly ho2(); //未知,编译器自动生成的行为不可控制

//static HeapOnly ho4; //静态区的对象也受编译器控制析构,所以也不能正常定义

HeapOnly *ho3 = new HeapOnly; //没有可访问的析构函数类只能在堆上定义对象,因为堆上的资源由用户自己释放,所以可以正常定义
//delete ho3; //必须是公开的析构函数,才能在栈上使用delete(在栈域访问类域私有成员)
ho3->Destory(); //进到类域内部的函数能够访问私有成员,可以析构
return 0;
}
*/

//思路2:隐藏构造函数(常用,通用)
//封构造函数能够把在栈上 定义或new 封掉
/* class HeapOnly
{
public:
static HeapOnly* createObj(int x = 0) // static函数在类域内,不受访问修饰符约束,能够看得见成员函数
{
HeapOnly* p = new HeapOnly(x); //在类域内new一个对象,就是在类域内调用构造,定义的空间位于堆区
return p;
}
private:
HeapOnly(int x = 0) :_x(0)
{}
HeapOnly(const HeapOnly& ho) = delete;
HeapOnly& operator=(const HeapOnly& ho) = delete;
int _x;
};

int main()
{
HeapOnly* ho = HeapOnly::createObj(0); //在栈上定义一个指针,调用类域内的静态函数createObj去new一个对象,得到对象的指针
//HeapOnly ho1(*ho); //还需要禁掉拷贝构造
return 0;
}
*/

//------------------------------------------------------------ 只能在堆上创建对象的类__End;

 

// 设计只能在栈上定义类(不能完全做到,最多只能禁止堆,不能禁止static区)
/*
class StackOnly
{
public:
static StackOnly createObj(int x = 0)
{
return StackOnly(x); //传值返回
}
static StackOnly create_move_Obj(int x = 0)
{
return std::move(StackOnly(x)); //画蛇添足
}
StackOnly(const StackOnly& ho):_x(ho._x)
{}
StackOnly(StackOnly&& ho):_x(ho._x)
{}

private:
StackOnly(int x = 0):_x(0)
{}
int _x;
};

int main()
{
StackOnly ho = StackOnly::createObj(0); //传值返回 -- 需要拷贝构造
static StackOnly sho = ho; // 有拷贝构造就能创建static对象

StackOnly ho1 = StackOnly::create_move_Obj(1); //如果禁止掉拷贝构造而使用移动构造
static StackOnly sho1 = std::move(ho1); // 有移动构造也能创建static对象
return 0;
}
*/


//设计一个不能被继承的类
/*
C++98:构造函数私有化
// 原因: 派生类在初始化时必须要显式调用父类构造函数帮助父类私有化,父类构造函数私有后,子类就无法完成初始化了

C++11:使用final关键字,final修饰类,表示该类不能被继承

class A  final //最终
{
   // ....
};
*/

//设计模式
/*

设计模式：
设计模式(Design Pattern)是一套被反复使用、多数人知晓、经过分类的、代码设计经验的总结。
为什么会产生设计模式这样的东西呢？
就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗,就发现打仗也是有套路的,
后来孙子就总结出了《孙子兵法》. -- 类似

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

//C++不太关注设计模式,Java比较关注

C++常见设计模式:
适配器
迭代器
单例 (最广泛)
工厂
观察者

 

*/

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

 

单例模式有两种实现模式： 1.饿汉模式 2. 懒汉模式

使用场景：只要某个类的对象在全局只有一份,就可以使用单例模式


单例模式的实现:
1.把这些数据放进一个类里面,把这个类设计成单例类
2.把这个类设计成只允许在堆上实例的类
3.选择饿汉或懒汉模式

*/


//饿汉模式:
/*
进程一启动就会创建一个唯一的实例对象,在main函数执行前就创建了.

// 优点：简单,没有线程安全问题(因为main函数之前没有多线程,而饿汉在main之前就new了)
// 缺点：可能会导致进程启动慢(如果单例对象很大)，且会占用资源(没用也创建),且如果有多个单例类对象实例启动顺序不确定(main内的代码执行流是确定的,其他的不确定。

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


class Singleton
{
public:
static Singleton* getInstance()
{
return _ins;
}
void Add(const std::string& s)
{
_mtx.lock();
_v.push_back(s);
_mtx.unlock();
}
void Print()
{
_mtx.lock();
for (auto& v : _v)
{
std::cout << v << std::endl;
}
_mtx.unlock();
}
private:
Singleton()
{}
Singleton(const Singleton& ins) = delete; //如果没有加锁,则有防拷贝作用
//禁止拷贝构造后,operator可以不防止(调不到拷贝构造了),不防止有没有其他问题还不清楚,最好还是写

std::vector<std::string> _v; // 不用给大小,对象实例化后会自动定义一个空的,后面push_back即可
static Singleton* _ins;
std::mutex _mtx;
};
Singleton* Singleton::_ins = new Singleton; //在堆上实例化

int main()
{
//Singleton::getInstance()->Add("张三");
//Singleton::getInstance()->Add("李四");
//Singleton::getInstance()->Add("王五");
//Singleton::getInstance()->Print();

int n = 10;

std::thread t1([n]() {
for (int i = 0; i < n; i++)
{
srand((size_t)time(0)); //srand只在当前进程有效
Singleton::getInstance()->Add(std::string("线程1: ") + std::to_string(rand()));
}
});
std::thread t2([n]() {
for (int i = 0; i < n; i++)
{
srand((size_t)time(0));
Singleton::getInstance()->Add(std::string("线程2: ") + std::to_string(rand()));
}
});


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

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

return 0;
}


*/

 

 

 


//懒汉模式：
/*
如果单例对象一开始就进行初识化,构造十分耗时或者占用很多资源，还伴随一些IO行为如 加载插件，初始化网络连接，读取文件等等，
而且有可能该对象在程序运行时不会用到,就会导致程序启动时非常缓慢。这种情况使用懒汉模式（延迟加载）更好.

懒汉模式在启动后能够使用多线程,一个线程IO,另一个线程执行业务等.一个线程不会影响另一个线程,能够缓解慢、卡顿等问题(多核的好处)
多核，并发能让不关联的业务分别独立执行,提高效率

优点：只在初次使用实例对象时，创建对象。进程启动无负载。多个单例实例启动顺序能够自由控制. 能够解决饿汉的所有缺点
缺点：复杂


class Singleton
{
public:
static Singleton* getInstance()
{
//双检查加锁
//设计模式专业术语:双重检查锁定模式一种软件设计模式,用来减少并发系统中竞争和同步的开销。
//双重检查锁定模式首先验证锁定条件(第一次检查)，只有通过锁定条件验证才真正的进行加锁逻辑并再次验证条件(第二次检查)。
if (!_ins) //提高效率,减少加锁解锁
{
_imtx.lock();
if (!_ins) //用于保证线程安全和 只new一次
{
_ins = new Singleton;
}
_imtx.unlock();
}
return _ins;
}

//手动释放_ins对象,手动调用del并不会影响到_gc,因为静态类型不受对象控制
static void delInstance() //为什么是静态? 因为没有对象,只有类型,通过类域展开来调用
{
//不需要双检查加锁了,因为销毁对象极少调用.开销不大
_imtx.lock();
if (_ins)
{
delete _ins; //之后会自动调用_ins的析构
_ins = nullptr;
}
_imtx.unlock();
}

//资源自动回收对象GC
struct GC
{
~GC()
{
std::cout<<"~GC"<<std::endl;
delInstance();
}
};
static struct GC _gc; //声明一个静态GC成员,静态成员不受_ins对象控制,只在生命周期到了(结束结束)后自动释放
// 因为定义在堆的对象在程序结束时不会自动释放/delete,所以设计GC辅助
// 1.当程序快结束前(main return之后),静态变量的生命周期结束,OS会自动delete静态变量,即~GC且释放_gc,然后delInstance,~Singleton且释放_ins
// 因此GC能够保证单例对象能在程序结束时自动完成析构和释放工作

void Add(const std::string& s)
{
_vmtx.lock();
_v.push_back(s);
_vmtx.unlock();
}
void Print()
{
_vmtx.lock();
for (auto& v : _v)
{
std::cout << v << std::endl;
}
_vmtx.unlock();
}
~Singleton() //对象要没的时候(delete this)才会调用
{
//持久化操作... (持久化就是变成长久保存,一般就是写到文件,文件在磁盘中,就是持久化的一种实现)
// 要求在析构时,将数据保存在文件中.
}

private:
Singleton()
{}
Singleton(const Singleton& ins) = delete; //如果没有加锁,最好还是写

std::vector<std::string> _v; // 不用给大小,后面push_back即可
std::mutex _vmtx;

static Singleton* _ins;
static std::mutex _imtx; //// 静态锁不属于对象,在静态区,锁的是静态区的对象
};
Singleton* Singleton::_ins = new Singleton; //在堆上实例化
std::mutex Singleton::_imtx;
Singleton::GC Singleton::_gc;

int main()
{
//Singleton::getInstance()->Add("张三");
//Singleton::getInstance()->Add("李四");
//Singleton::getInstance()->Add("王五");
//Singleton::getInstance()->Print();

int n = 10;
//srand((size_t)time(0)); 影响不到两个线程,定不定义无所谓
std::thread t1([n]() {
for (int i = 0; i < n; i++)
{
//srand((size_t)time(0)); //srand只在当前进程有效,但这里定义变化不大了,需要寻求新的随机数方法
Singleton::getInstance()->Add(std::string("线程1: ") + std::to_string(rand()));
}
});
std::thread t2([n]() {
for (int i = 0; i < n; i++)
{
//srand((size_t)time(0));
Singleton::getInstance()->Add(std::string("线程2: ") + std::to_string(rand()));
}
});


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

Singleton::getInstance()->Print();
//Singleton::delInstance(); //手动释放,
return 0;
//程序结束才会释放静态,因为静态不受对象控制,只随生命周期(整个程序运行期间)
}


//懒汉模式方式2
class Singleton
{
public:
static Singleton* GetInstance()
{
// C++11之前，这里不能保证初始化静态对象的线程安全问题
// C++11之后，这里可以保证初始化静态对象的线程安全问题 --- 很复杂,有机会再研究
static Singleton inst; //局部静态对象只会在第一调用时初始化

return &inst;
}

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

_v.push_back(str);

_vmtx.unlock();
}

void Print()
{
_vmtx.lock();

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

_vmtx.unlock();
}

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

private:
// 限制类外面随意创建对象
Singleton()
{
cout << "Singleton()" << endl;
}

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

private:
mutex _vmtx;
vector<string> _v;
};


int main()
{
Singleton::GetInstance();
Singleton::GetInstance();


return 0;
}


*/

 


/

原文链接：https://www.cnblogs.com/DSCL-ing/p/18038382

猜你在找的C&C++相关文章

C++11新特性的一些用法举例②
/** C+⬑ * 默认成员函数 原来C++类中，有6个默认成员函数： 构造函数 析...
C++特殊类的设计与单例模式
#pragma once // 1. 设计一个不能被拷贝的类/* 解析:拷贝只会放生在两个场景中：拷贝构造函...
C++11的类型转换
C类型转换 C语言:显式和隐式类型转换 隐式类型转化：编译器在编译阶段自动进行，能转就转，...
C++异常的基本概念与用法
//异常的概念/*抛出异常后必须要捕获,否则终止程序(到最外层后会交给main管理,main的行为就...
C++的智能指针
#pragma once /*Smart pointer 智能指针;灵巧指针 智能指针三大件//1.RAII//2.像指针一样使...
C++11标准库 原子变量 <atomic> 梳理
目录&lt;atomic&gt;原子操作的概念CAS实现原理CAS操作的伪代码：使用CAS完成变量的...
C++11新特性的一些用法举例①
//字符串字面量/*常用:1.原始字符串字面量 括号内保持原样输出 没有转义字符,如n不再是换行...
C++11标准库 条件变量 <condition_variable> 梳理
目录&lt;condition_variable&gt;condition_variable类类方法生产者消费者模型 -- ...
C++11智能指针 unique_ptr、shared_ptr/weak_ptr、make_shared、循环引用、定制删除器 (万字长文)
目录智能指针场景引入 - 为什么需要智能指针？内存泄漏什么是内存泄漏内存泄漏的危害内存泄...
C++多态
/** 多态/动态调用 * * * 1.虚函数/虚拟函数 * 语法:在函数前面加上virtual * * 1.1虚函数...
PHPJavaJava SEPythonC#C&C++RubyVBasp.NetGoPerlnettyDjangoDelphiJsp.NET CoreSpringFlaskSpringbootSpringMVCLuaLaravelMybatisAspGroovyThinkPHPYiiswoole
文件时间pythonm相等性PHP Warning时间问题问题解决pcntl_signal采样点wav模块动态文本调用频率限制对外暴露多个访问请求更新数据表模型结构type()方法比较速度手写体sobel算子保存模型Image类nn.Conv2dpytorch1.0kaggleDCGAN交并比range()用法打印模型反卷积卷积