C++特殊类设计与类型转换

常见的特殊类的设计

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

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

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

[4. 请设计一个类，不能被继承](#4. 请设计一个类，不能被继承)

5.请设计一个类，只能创建一个对象（单例模式）

[3.1 stacit_cast](#3.1 stacit_cast)

[3.2 reinterpret_cast](#3.2 reinterpret_cast)

[3.3 const_cast](#3.3 const_cast)

[3.4 dynamic_cast](#3.4 dynamic_cast)

4.RTTI（了解）

5.常见面试题

常见的特殊类的设计

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

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

C++98写法：

将拷贝构造函数与赋值运算符重载只声明不定义 ，并且将其访问权限设置为私有即可。

cpp 复制代码

class CopyBan
{
	//...
private:
	CopyBan(const CopyBan& c);
	CopyBan& operator=(const CopyBan& c);
	//...
};

原因：1.设置成私有：如果只声明没有设置成private，用户自己如果在类外定义了，就不能禁止拷贝了。

2.只声明不定义：不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就不会防止成员函数内部拷贝了。

C++11写法：

C++11扩展delete的用法，delete除了释放new申请的资源外，如果在默认成员函数后面跟上=delete，表示让编译器删除掉该默认成员函数。

cpp 复制代码

class CopyBan
{
	//...
	CopyBan(const CopyBan& c)=delete;
	CopyBan& operator=(const CopyBan& c)=delete;
	//...
};

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

实现方式：

1.将类的构造函数设置为私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。

2.提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

cpp 复制代码

class HeapOnly
{
public:
	static HeapOnly* CreateHeapObj()
	{
		return new HeapOnly;
	}
private:
	HeapOnly()
	{ }

	//C++98方式
	//1.只声明，不实现。因为实现可能会很麻烦，而你本身并不需要
	//2.声明成私有
	HeapOnly& operator=(const HeapOnly&);

	//C++11方式
	HeapOnly& operator=(const HeapOnly&) = delete;
};

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

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

cpp 复制代码

class StackOnly
{
public:
	static StackOnly CreateStackObj()
	{
		return StackOnly();
	}

	//禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
	//StackOnly obj = StackOnly::CreateStackObj();
	//StackOnly* ptr = new StackOnly(obj);
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;

private:
	StackOnly()
		:_a(0)
	{ }

	int _a;
};

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

C++98方式：把类的构造函数私有化，派生类调不到基类的构造函数就无法继承。

cpp 复制代码

C++98中构造函数私有化，派生类中调不到基类的构造函数，则无法继承
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{ }
};

C++11方法：final关键字，final修饰类，表示该类不能被继承。ps(final还能修饰虚函数，表示该虚函数不能被重写。)

cpp 复制代码

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

5.请设计一个类，只能创建一个对象（单例模式）

设计模式：

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

单例模式：

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

单例模式有两种实现模式：

1.饿汉模式：

（一开始（main函数之前）就创建单例对象）

就是说不管你将来用还是不用，程序启动时就会创建一个唯一的实例对象。

cpp 复制代码

饿汉模式
优点：简单
缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
class Singleton
{
public:
	static Singleton* GetInstance()
	{
		return &m_instance;
	}
private:
	//构造函数私有化
	Singleton(){}
	
	//C++98防止拷贝
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);

	//or

	//C++11
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	static Singleton m_instance;
};

Singleton Singleton::m_instance;//在程序入口之前就完成单例对象的初始化

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

2.懒汉模式：

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

cpp 复制代码

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
		if (nullptr == m_pInstance)
		{
			m_mtx.lock();//or--- unique_lock<mutex> lock(m_mtx);
			if (nullptr == m_pInstance)
			{
				m_pInstance = new Singleton();
			}
			m_mtx.unlock();
		}
	}

	//实现一个内嵌的垃圾回收类
	class CGarbo
	{
	public:
		~CGarbo()
		{
			if (Singleton::m_pInstance)
				delete Singleton::m_pInstance;
		}
	};
	//定义一个静态成员变量，程序结束时，系统自动调用它的析构函数从而释放单例对象
	static CGarbo Garbo;
    main函数结束，调用它的析构，从而释放单例对象

private:
	//构造函数私有化
	Singleton(){}

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

	static Singleton* m_pInstance;//单例对象指针
	static std::mutex m_mtx;	//互斥锁
};

Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
std::mutex Singleton::m_mtx;

C++11中创建单例（懒汉模式）最简单的方法

cpp 复制代码

class Singleton
{
public:
    局部的静态对象，是在第一次调用时初始化
	static Singleton& GetInstance()
	{
		static Singleton inst;
		return inst;
	}
private:
	Singleton()
	{
		std::cout << "Singleton" << std::endl;
	}
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

};

C++11之前，这个代码是不安全的，编译器不支持。

C++11之后，可以保证局部静态对象的初始化是线程安全的，只初始化一次。（C++11之后这个操作变成原子的了。）

C++中的类型转换

1.C语言中的类型转换

在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转换 ，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。
1.隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败。

2.显式类型转换：需要用户自己处理。

cpp 复制代码

void Test()
{
	int i = 1;
	//隐式类型转换
	double d = i;
	printf("%d,%.2lf\n", i, d);

	int* p = &i;
	//显式类型转换
	int address = (int)p;
	printf("%x,%d\n", p, address);
}

缺陷：转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换。

2.为什么C++需要四种类型转换

C风格的转换形式很简单，但是有不少缺点：

1.隐式类型转换有些情况下可能会出问题：比如说数据精度的丢失。

2.显式类型转换将所有情况混合在一起，代码不够清晰。
因此C++提出了自己的类型转换的风格，注意C++要兼容C语言，所以在C++中还是可以使用C语言那一套的类型转换。

3.C++强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：

static_cast , reinterpret_cast , const_cast , dynamic_cast

3.1 stacit_cast

static_cast用于非多态类型的转换（静态转换） ，编译器隐式执行的任何类型转换都可用static_cast ，但它不能用于两个不相关的类型进行转换 。（用于两个相关类型/相近类型之间，C里的隐式类型转换都可用这个static_cast强转。）

cpp 复制代码

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

3.2 reinterpret_cast

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型。（可用于两个不相关类型之间进行强转。）

cpp 复制代码

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	std::cout << a << std::endl;
	
	这里使用static_cast会报错，应该使用reinterpret
	//int* p = static_cast<int*>(a);
	int* p = reinterpret_cast<int*>(a);

	return 0;
}

3.3 const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值。（去掉const属性。）

cpp 复制代码

int main()
{
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	std::cout << a << std::endl;

	return 0;
}

3.4 dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用（动态转换）。
向上转型：子类对象指针/引用 ->父类指针/引用（不需要转换，赋值兼容规则）。

向下转型：父类对象指针/引用->子类指针/引用（用dynamic_cast转型是安全的）。

注意：

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

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

cpp 复制代码

Base* b = new Derived();  b实际上指向Derived对象

 情况1：成功转换
Derived* d1 = dynamic_cast<Derived*>(b);  
 成功：b实际指向Derived对象，d1是有效的Derived指针

 情况2：转换失败
Base* b2 = new Base();  // b2指向纯Base对象
Derived* d2 = dynamic_cast<Derived*>(b2);
 失败：b2不是Derived对象，d2 == nullptr

cpp 复制代码

class A
{
public:
	virtual void f(){}
};

class B :public A
{};

void fun(A* pa)
{
	//dynamic_cast会先检查是否能成功转换成功，能成功则转换，不能则返回
	B* pb1 = static_cast<B*>(pa);
	B* pb2 = dynamic_cast<B*>(pa);

	std::cout << "pb1:" << pb1 << std::endl;
	std::cout << "pb2:" << pb2 << std::endl;
}

int main()
{
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}

注意：

强制类型转换关闭或挂起了正常的类型检查 ，每次使用强制类型转换前，程序员应该仔细考虑是否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制类型转换值的作用域，以减少发生错误的机会。强烈建议：避免使用强制类型转换。

4.RTTI（了解）

RTTI:Run-time Type identification的简称，即：运行时类型识别。

C++通过一下方式来支持RTTI：

1.typeid运算符。

2.dynamic_cast运算符。

3.decltype。

5.常见面试题

1.C++中的四种类型转换分别是：static_cast，reinterpret_cast，const_cast，dynamic_cast。

2.说说四种类型转换的应用场景。

static_cast适用于两种类型相近的强制转化，dynamic_cast适用于多态类型的向下转换（安全检查）（向上转换本来就是安全的）。cosnt_cast适用于删除变量的const属性。reinterpret_cast适用于任意类型之间的转换（危险）。