【C++】特殊类设计+单例模式+类型转换


需要云服务器等云产品来学习Linux的同学可以移步/-->腾讯云<--/-->阿里云<--/-->华为云<--/官网,轻量型云服务器低至112元/年,新用户首次下单享超低折扣。


 目录

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

1、C++98

2、C++11

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

1、将构造设为私有

2、将析构设为私有

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

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

1、C++98

2、C++11

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

1、饿汉模式设计单例模式

2、懒汉模式设计单例模式

3、单例对象的释放

4、一种比较简洁但是可能存在线程安全的单例懒汉模式

六、类型转换

1、C语言类型转换

2、C++新增四种强制类型转换

2.1static_cast

2.2reinterpret_cast

2.3const_cast

2.4dynamic_cast

3、RTTI


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

1、C++98

class CopyBan
{
private:
	CopyBan(const CopyBan& cb);
	CopyBan& operator=(const CopyBan& cb);
};
int main()
{

	return 0;
}

        1、将拷贝构造和赋值运算符重载设置为私有;

        2、仅仅私有还不够,这并不能防止类内部就行拷贝。还要对拷贝构造和赋值运算符重载只声明却不实现。

2、C++11

class CopyBan
{
	CopyBan(const CopyBan& cb) = delete;
	CopyBan& operator=(const CopyBan& cb) = delete;
};

        C++11直接使用delete禁用拷贝构造和赋值运算符重载。

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

1、将构造设为私有

【C++】特殊类设计+单例模式+类型转换_第1张图片

        1、将构造设为私有,防止外部构造,并提供一个CreateObj的函数用于构造堆区对象;

        2、但是外部需要对象来调用CreateObj函数来构造对象,所以需要将CreateObj设置为静态函数,无需对象也能调用。

        3、外部通过CreateObj函数构造一个对象后,外部可以利用这个对象的指针拷贝构造一个栈区的对象,需要禁用拷贝构造。

2、将析构设为私有

【C++】特殊类设计+单例模式+类型转换_第2张图片

        将析构函数设置为私有,栈区对象由于无法析构所以无法创建。堆区对象需要手动调用自己写的清理函数释放。

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

【C++】特殊类设计+单例模式+类型转换_第3张图片

        1、将构造函数私有;

        2、提供一个静态的CreateObj方法用于构造栈区对象;

        3、但是无法防止外部构造静态对象。

        4、如果想彻底禁止生成静态的对象,需要再禁用拷贝构造。不过这样这个类只能生成临时对象或者引用的对象了,不能修改。

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

1、C++98

class FinalClass
{
	static FinalClass CreateObj()
	{
		return FinalClass();
	}
private:
	FinalClass()
	{}
};

        1、禁用构造函数;

        2、提供一个静态的CreateObj函数供外部创建父类对象,但是子类会因为构造私有的继承不可见的原因无法构造出父类对象,所以无法继承。

2、C++11

class FinalClass final
{
private:
	
};

        C++11直接使用final关键字

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

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

1、饿汉模式设计单例模式

class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		return _sins;
	}
	void Insert(string name, int money)
	{
		_info[name] = money;
	}
	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
	}
private:
	InfoSingleton()
	{}
	InfoSingleton(const InfoSingleton&) = delete;
	InfoSingleton& operator=(const InfoSingleton&) = delete;
	map _info;
	static InfoSingleton _sins;
};
InfoSingleton InfoSingleton::_sins;
int main()
{
	InfoSingleton& s = InfoSingleton::GetInstance();//使用单例对象
	s.Insert("小明", 100);
	s.Insert("小红", 50);
	s.Insert("小绿", 130);
	s.Print();
	cout << endl;
	s.Insert("小绿", 10086);
	s.Print();
	return 0;
}

        饿汉模式:在main函数被加载之前就创建好对象。(全局和静态将在main函数之前被加载)

        1、私有构造函数,禁用拷贝构造和赋值运算符重载;

        2、在类中声明、外部定义一个静态的对象,用于调用类中私有的构造函数,同时作为单例对象被使用;

        3、在类中提供一个获取静态对象的函数GetInstance,为了外部可调用,所以将该函数设置为静态。

饿汉模式的特点:

1、单例对象初始化时,数据太多会导致启动慢;

2、如果多个单例类有初始化的依赖关系,饿汉模式无法控制。例如A和B都是单例类,因为B的启动依赖A,所以需要先初始化A,再初始化B,但是饿汉模式无法控制对象的初始化顺序。

3、饿汉模式创建的对象绝对不会有线程安全问题,因为该模式的对象在main函数之前已经被创建好了,mian函数之前线程都没启动呢。

2、懒汉模式设计单例模式

【C++】特殊类设计+单例模式+类型转换_第4张图片

        懒汉模式:第一次获取单例对象的时候创建对象;

        1、私有构造函数,禁用拷贝构造和赋值运算符重载;

        2、在类中声明、外部定义一个静态的对象指针

        3、在类中提供一个获取静态对象的函数GetInstance,为了外部可调用,所以将该函数设置为静态。

        4、它与饿汉的写法区别如图红色标记处。

懒汉模式的特点:

1、对象在main函数之后才会创建;

2、可以主动控制对象的创建时机。

3、创建对象时存在线程安全问题,如果多个线程同时进入红框区域,会可能new多个对象,最后一个创建的对象指针会覆盖之前创建的对象指针,导致内存泄露。

        懒汉模式需要加锁解决线程安全问题:

【C++】特殊类设计+单例模式+类型转换_第5张图片

        不过红框中new也可能会失败,再套一层try/catch看着太累,可以使用RAII锁解决:

【C++】特殊类设计+单例模式+类型转换_第6张图片

        new这里还要try一下异常,main里函数捕获这个异常。(写漏了)

3、单例对象的释放

        1、一般单例对象不需要考虑释放,资源会在进程结束时自动释放;

        2、释放的写法如下:可以手动清理,将一些资源保存:可手动调用DelInstance进行资源的回收,main函数结束时,操作系统也会自动回收单例对象的资源。

【C++】特殊类设计+单例模式+类型转换_第7张图片

4、一种比较简洁但是可能存在线程安全的单例懒汉模式

class InfoSingleton
{
public:
	static InfoSingleton& GetInstance()
	{
		//静态局部变量是在main函数之后才创建初始化
		static InfoSingleton sinst;
		return sinst;
	}
	void Insert(string name, int money)
	{
		_info[name] = money;
	}
	void Print()
	{
		for (auto kv : _info)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
	}
private:
	InfoSingleton()
	{}
	InfoSingleton(const InfoSingleton&) = delete;
	InfoSingleton& operator=(const InfoSingleton&) = delete;
	map _info;
};

        1、私有构造函数,禁用拷贝构造和赋值运算符重载;

        2、通过GetInstance返回静态对象(静态局部变量是在main函数之后才创建初始化)

这种方式构建的单例懒汉模式在C++11发布之前会有线程安全问题,多线程环境下可能会造成静态对象被初始化多次;而C++11规定静态局部变量是线程安全的,可以放心使用。 

六、类型转换

1、C语言类型转换

        1、隐式类型转换2、强制类型转换。

2、C++新增四种强制类型转换

        C++尤其认为隐式类型转化有些情况下可能会出问题:比如数据精度丢失。

2.1static_cast

int main()
{
	double d = 12.34;
	int a = static_cast(d);
	cout << a << endl;
	return 0;
}

static_cast适用于相似类型的转换。(可以隐式类型转换的都能用static_cast) 

2.2reinterpret_cast

int main()
{
	double d = 12.34;
	int a = static_cast(d);
	cout << a << endl;
	// 这里使用static_cast会报错,应该使用reinterpret_cast
	//int *p = static_cast(a);
	int* p = reinterpret_cast(a);
	return 0;
}

reinterpret_cast适用于不相关类型之间的转换。(不能隐式类型转换,只能强制类型转换的用reinterpret_cast)

2.3const_cast

【C++】特殊类设计+单例模式+类型转换_第8张图片

const_cast用于删除变量的const属性。需要关注内存可见性问题。 

        编译器对const变量会有优化,认为const变量不会被改变,编译器在优化代码时可能会将变量放到寄存器或者其他高速缓存中。可以在a初始化时加上volatile关键字,加了volatile关键字后,对变量的读取和写入操作会从内存中进行,而不是从缓存中进行。

2.4dynamic_cast

        dynamic_cast用于父类的指针和引用转换为子类对象的指针和引用。(动态转换)

        向上转型:子类对象指针/引用->父类指针/引用(不需要转换,赋值兼容规则)

        向下转型:父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)

class A
{
public:
	virtual void f() {}
	int _a = 0;
};
class B : public A
{
public:
	int _b = 0;
};
void fun(A* ptr)
{
	//B* bptr = (B*)ptr;//直接转换是不安全的,父给子存在非法访问隐患
	B* bptr = dynamic_cast(ptr);
	if (bptr)//如果转换成功
	{
		bptr->_a++;
		bptr->_b++;
		cout << bptr->_a;
		cout << bptr->_b;
	}
}
int main()
{
	A aa;
	B bb;
	fun(&aa);//转换失败
	fun(&bb);//转换成功
	return 0;
}

注意:

1. dynamic_cast只能用于父类含有虚函数的类

2. dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回0

3、RTTI

        RTTI:Run-time Type identifification的简称,即:运行时类型识别。

        C++通过以下方式来支持RTTI:

1. typeid运算符 
2. dynamic_cast运算符 
3. decltype

你可能感兴趣的:(C++,c++,开发语言,设计模式,类型转换)