c++11特殊类设计,单例模式

设计一个类,不能被拷贝

  1. 拷贝只会放生在两个场景中:拷贝构造函数以及赋值运算符重载,因此想要让一个类禁止拷贝,只需让该类不能调用拷贝构造函数以及赋值运算符重载即可
  2. c++98的方式同名对象在类域中使用拷贝构造和赋值重载,但是c++11的delete后同名对象在类域中不可以使用拷贝和赋值重载。

c++98方式

通过将拷贝构造和赋值重载私有化,同时定义时不写函数体 。

class No_Copy
{
public:
	No_Copy()
	{
		;
	}
	void f()
	{
		No_Copy n1;
		No_Copy n2(n1);

	}
	
private:	

	No_Copy(const No_Copy& cpy)
	{
	;
	}
    No_Copy &operator=(const No_Copy& cpy)
    {
        ;
    }
};
//通过类域定义,因为在类中已经定义了--内联定义,编译会保错
//No_Copy::No_Copy(const No_Copy& cpy)
//{
//	cout << "hellowoerd" << endl;
//}
int main()
{
	No_Copy nocpy1;
	nocpy1.f();
}

C++11:

  1. 通过关键字delete强制不生成拷贝构造和赋值重载。

​ 2. 即使是类域中的同名对象也不可使用delete后的拷贝构造和赋值重载。

class No_Copy
{
public:
	No_Copy()
	{
		;
	}
	No_Copy(const No_Copy& cpy) = delete;
	No_Copy&operator =(const No_Copy& cpy) = delete;
private:
};

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

对象存在有:堆区,栈区,静态区(全局变量),常量区

主流:

由RAII思想,当在类外,创建对象是会自动调用构造函数,因此把构造函数私有化,同时为了防止在栈或者静态区被拷贝,拷贝构造delete。赋值重载是针对已存在的2个对象,既然已经合法存在,说明是在堆上创建的,不需要私有化赋值。最后通过一个静态接口,在堆上创建对象

c++11特殊类设计,单例模式_第1张图片

其它

将析构函数私有化,这样编译器在栈还是静态区,只有创建对象就会报错,但是对于在堆上申请的不会,之后通过成员函数进行delete。

c++11特殊类设计,单例模式_第2张图片

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

方法一:通过静态函数返回

c++11特殊类设计,单例模式_第3张图片

方法二:强制不生成new和delete

c++11特殊类设计,单例模式_第4张图片

设计一个类,不能被继承

c++98

C++98中构造函数私有化,派生类中调不到基类的构造函数。则无法继承 。派生类创建对象必须调用基类的构造函数

class NonInherit
{
public:
static NonInherit GetInstance()
{
return NonInherit();
}
private:
NonInherit()
{}
}

c++11

通过关键字final

class A fina
{

}

设计一个类,只能创建一个对象—单列模式

设计模式

设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。同STL一样,具有泛性。
使用设计模式的目的:为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化;设计模式是软件工程的基石脉络,如同大厦的结构一样 。

单例模式

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

饿汉模式

程序启动时,main函数之前就创建一个唯一的实例对象。

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

//饿汉模式,上来就吃
class Signleton
{

public:
	static Signleton* Get_Signleton()
	{
		return _pslt;
	}
	void Print()
	{
		cout << "helloword" << endl;
	}

private:
	Signleton()=default;
	Signleton(const Signleton& slt) = delete;
	Signleton & operator=(const Signleton& slt) = delete;
	static Signleton* _pslt;
};
Signleton* Signleton::_pslt = new Signleton;

int main()
{
	Signleton::Get_Signleton()->Print();
	return 0;
}

懒汉模式

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

//懒汉模式模式,用时再吃
class Signleton
{

public:
	static Signleton* Get_Signleton()
	{
		if (_pslt == nullptr)
		{
			_pslt = new Signleton;
		}
		return _pslt;
	}
	void Print()
	{
		cout << "helloword" << endl;
	}

private:
	Signleton() = default;
	Signleton(const Signleton& slt) = delete;
	Signleton& operator=(const Signleton& slt) = delete;
	static Signleton* _pslt;
};
Signleton* Signleton::_pslt =nullptr;

int main()
{
	Signleton::Get_Signleton()->Print();
	return 0;
}

饿汉模式与懒汉模式对比

饿汉模式:

逻辑简单,但初始化顺序不确定,如果有依赖关系就会有问题,饿汉对象初始化慢且多个饿汉单例对象会影响程序启动

懒汉特点:

复杂一点。第一次调用时初始化,可以控制初始化顺序,延迟加载初始化,不影响程序启动。

资源释放

一般单例模式不考虑内存释放。—以目前的水准不会解释

你可能感兴趣的:(C++,单例模式,c++,开发语言)