C++：特殊类设计和四种类型转换

这篇文章介绍了C++：特殊类设计和四种类型转换，分享给大家做个参考，收藏Java资料网收获更多编程知识

一、特殊类设计

1.1 不能被拷贝的类

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

C++98：

1、将拷贝构造函数与赋值运算符重载只声明不定义。（防自己人）

        不定义是因为该函数根本不会调用，定义了其实也没有什么意义，不写反而还简单，而且如果定义了就可能导致成员函数进行内部拷贝了。

2、并且将其访问权限设置为私有即可。（防外人）

        如果只声明没有设置成private，用户自己如果在类外定义了，就可以不能禁止拷贝了

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

C++11:

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

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

1.2 只能在堆上创建对象的类

思路1：

1. 将类的构造函数私有，拷贝构造声明成私有（可以直接delete掉）。防止别人调用拷贝在栈上生成对象。

      注意：拷贝构造可以直接delete掉，但是构造函数不行！！因为我们还需要利用构造函数在堆上创建对象。
2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建。

     注意：这里涉及到的是先有鸡还是先有蛋的问题，因为如果不去创建这个对象就没有办法去调用他的构造函数，但是没有调用构造函数就没有办法创建对象。所以这里必须通过静态成员函数的返回值去构造堆对象。

class HeapOnly
{
public:
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly(){};
	HeapOnly(const HeapOnly&) = delete;
};


int main()
{
	HeapOnly*p = HeapOnly::CreateObject();
	return 0;
}

思路2：

1、相比较于上一种思路把构造函数私有、拷贝构造delete，也可以选择将析构函数给设成私有。

      析构函数设置成私有同样会导致对象无法在栈上进行创建。因为自定义类型在栈帧中销毁的时候会去自动调用他的析构函数，但是因为调不到所以会报错。

2、封装一个destory的成员函数，这样我们可以手动释放堆空间的资源。

      在堆上创建对象是用指针去接受，所以并不影响，但是内存需要我们去手动释放，因此我们需要封装destory的成员函数去调用delete，这样delete可以对应调用到析构函数。 这里有两个方案：一种是设置能静态成员函数（类域调用），一种是设置成普通成员函数（对象自己调用）。

class HeapOnly
{
public:
	//方案1 
	static void Destroy(HeapOnly* hp)
	{
		delete hp;
	}
	//方案2
	void Destroy()
	{
		delete this;
	}
private:
	~HeapOnly() {};
};


int main()
{
	//HeapOnly H; 调不到析构函数，无法创建
	//静态成员函数释放
	HeapOnly* ptr = new HeapOnly;
	HeapOnly::Destroy(ptr);
	//普通成员函数释放
	HeapOnly* ptr2 = new HeapOnly;
	ptr2->Destroy();

	return 0;
}

1.3 只能在栈上创建对象的类

1、new和delete是全局的运算符重载函数，因此我们只要将这两个给禁用掉，就不会在堆上创建对象。

      需了解具体声明：void* operator new(size_t size) 和 void operator delete(void* p) 。实现类专属的operator new和delete 这样new这个类对象时，operator new就会调用这个，不会调全局的。

	class StackOnly
	{
	public:
		static StackOnly CreateObj()
		{
			return StackOnly();
		}
		// 禁掉operator new可以把下面用new 调用拷贝构造申请对象给禁掉
		// StackOnly obj = StackOnly::CreateObj();
		// StackOnly* ptr3 = new StackOnly(obj);
		void* operator new(size_t size) = delete;
		void operator delete(void* p) = delete;
	private:
		int _a;
	};

	int main()
	{
	    StackOnly obj;
		//StackOnly* s = new StackOnly;
	}

但是没有办法去禁用C语言的相关函数。 

1.4 不能被继承的类

C++98：

构造函数私有化，这样子类调用不到父类的构造函数，无法实现继承

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

C++11：

直接用final关键字，可以使得该类无法被继承

class A final
{
// ....
};

1.5 控制可创建对象数量的类

设置一个静态int变量count，每创建一个对象就--count

class singleclass
{
public:
	static singleclass* getsingleclass()
	{
		if (count > 0)
		{
			count--;
			return new singleclass();
		}
		else
		{
			cout << "实例化失败" << endl;
			return nullptr;
		}
	}
private:
	static int count;
	singleclass() {};
};
int singleclass::count = 1;

int main()
{
	singleclass* s1 = singleclass::getsingleclass();
	singleclass* s2 = singleclass::getsingleclass();
}

二、类型转换

2.1 C语言中的类型转换

        在C语言中，如果赋值运算符左右两侧类型不同，或者形参与实参类型不匹配，或者返回值类型与接收返回值类型不一致时，就需要发生类型转化，C语言中总共有两种形式的类型转换：隐式类型转换和显式类型转换。

1、隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败。相近类型才可以进行隐式类型转换 ，比如int和double 他们本质上都是表示数据的大小。

int i = 1;
// 隐式类型转换
double d = i;

 double d=i ：首先会产生一个double类型的临时对象接收i，然后将临时对象拷贝给d。

2、显式类型转化：需要用户自己处理。需要有一定的关联性。比如int和int*

int i = 1;
int* p = &i;
// 显示的强制类型转换
int address = (int)p;
printf("%x, %d\n", p, address);
return 0;

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

2.2 C++中的类型转换

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

2.2.1 static_cast

       static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用（相近类型用static_cast->意义相似的类型）

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

 2.2.2 reinterpret_cast

        reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型（一定的关联，但是意义不相似的的类型用reinterpret_cast ）

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

2.2.3 const_cast

       const_cast最常用的用途就是删除变量的const属性，方便做赋值操作（const_cast的类型必须是对象的指针或者引用）

int main()
{
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << a << endl;
	cout << *p << endl;
	cout << &a << endl;
	cout << p << endl;
	//cout的缺陷
	char ch = 'x';
	cout << &ch << endl;
	return 0;
}

思考：为什么*p被修改了，a却没有被修改？？

       因为常量被存到寄存器中了，所以其实改变的是内存中的a，但是不是寄存器中的a。这其实是一种优化，如果我们想要去掉这种优化，用volatile关键字（告诉编译器不要优化，直接从内存中读取） 

2.2.4 dynamic_cast（针对父类指针或引用的向下转型）

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针/引用->父类指针/引用(不需要转换，赋值兼容规则)
向下转型：父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意：
1. dynamic_cast只能用于父类含有虚函数的类
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回nullptr。

思考：

1、为什么父类和子类明明是两种类型，但是向上转型不需要转换呢？？

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

	int _a = 0;
};

class B : public A
{

public:
	int _b = 1;
};

int main()
{
	B objb;
	A obja = objb;
	A& ra = objb;

	double d = 1.1;
	const int& i = d;

	return 0;
}

2、为什么向下转型是不安全的？？

      因为子类的指针或引用如果是父类对象，那么会存在一部分的越界！！！

3、为什么 dynamic_cast只能用于父类含有虚函数的类

        dynamic_cast转换是在运行时进行转换，因为只有对于这种类层次结构，才应该将派生类的地址赋给基类指针。运行时转换就需要知道类对象的信息（继承关系等）。C++对象模型中，对象实例最前面的就是虚函数表指针，通过这个指针可以获取到该类对象的所有虚函数，包括父类的。因为派生类会继承基类的虚函数表，所以通过这个虚函数表，我们就可以知道该类对象的父类，在转换的时候就可以用来判断对象有无继承关系。

　　所以虚函数对于正确的基类指针转换为子类指针是非常重要的。

4、dynamic_cast的使用原理

       父类指针或引用如果本来指向的是子类的对象，那么类型转化是安全的，如果原本指向的是父类的对象，那么转化是不安全的（有越界，但是编译器检查不出来)，所以dynamic_cast可以帮助我们去判断这种情况，如果不符合安全转化的条件，就会返回nullptr。

void fun(A* pa)
{
	//  向下转换：直接转换是不安全的
	// 如果pa是指向父类A对象，存在越界问题
	B* ptr = dynamic_cast<B*>(pa);
	if (ptr!=nullptr)
	{
		ptr->_a++;
		ptr->_b++;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}

int main()
{
	// 向下转换规则：父类对象不能转换成子类对象，但是父类指针和引用可以转换子类指针和引用
	B b1;
	A a;
	B b;
	fun(&a);
	fun(&b);
	return 0;
}

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

C风格的转换格式很简单，但是有不少缺点的：
1、隐式类型转化有些情况下可能会出问题：比如数据精度丢失

2、显式类型转换将所有情况混合在一起，代码不够清晰

3、为了提供更安全、更明确的类型转换，使得代码意图更为清晰

       因此C++提出了自己的类型转化风格，注意因为C++要兼容C语言，所以C++中还可以使用C语言的转化风格。因此C++的转化风格并非强制性的，只不过是程序员之间的一种规范。

2.4 RTTI

RTTI：Run-time Type identification的简称，即：运行时类型识别。RTTI只适用于包含虚函数的类。
C++通过以下方式来支持RTTI：
1. typeid运算符（返回指出对象类型的值）
2. dynamic_cast运算符（根据虚基表判断有无继承关系，并判断是否可以转化）
3. decltype（推断表达式返回值的类型）

2.5 相关面试题

1. C++中的4中类型转化分别是：_________、_________、_________、________

2.描述四种类型转化各自的应用场景。

文章来源:https://blog.csdn.net/weixin_51142926/article/details/139103311
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！