C++的四种强制转型与C的强制转型

在C++中有四种强制转型，但是也保留了C语言中的强制转型，从功能上来说C++的四种强制转型，只是对C方式强制转型的功能细分。

C语言方式的强制转型原型如下

（targetType）argument;
# 例如
（int）aDoubleNum;
(BaseClass *) derivedPtr;

在C++中，将强制转型细分为四种：

static_cast; # 用于同级变量之间的相互转型，如 int 转 double 等
const_cast; # 用于变量在恒定与非恒定之间的转型
dynamic_cast; # 用于安全向下转型或跨系转型
reinterpret_cast; # 用于函数指针的转型，但是不具有跨平台之间的可移植性

具体的实例见下列代码。通过以下代码的验证，我们可以看出来，CPP的转型方式能够完成的功能，C方式转型都能完成。因此我们说CPP转型只是C转型的细分。之所以在CPP中设置四种新的转型方式，是因为这四种CPP转型的表达式形式严谨、表意明确，更容易辨识。

#include<iostream>
#include <stdio.h>

#include "BaseClass.h"
#include "derivedClass.h"
#include "VerifyFunc.h"


int doSmoething()
{
	return 0;
}

void main()
{
	typedef void (* FuncPtr)();
	FuncPtr funcptrArray[10] = {NULL};

	int numA = 2;
	int numB = 3;
	double numC;
	DerivedClass son1;
	DerivedClass son2;
	BaseClass *pFather = &son1;
	const BaseClass *pCFather = &son2;

	// C cast
	std::cout<< "******* C cast ******" <<std::endl;
	numC = numA/numB;
	std::cout << "double type numC = " << numC << std::endl;

	numC = (double)numA/numB;
	std::cout << "double type numC = " << numC << std::endl;

	numC = numA/numB;
	std::cout << "double type numC = " << numC << std::endl;

	//VerifyBaseFunc(pCFather);   // syntax error,this function can only accept non-const
									// BaseClass pointer
	//VerifyBaseFuncConst(pFather);   // syntax error,this function can only accept const
									// BaseClass pointer

	VerifyBaseFunc((BaseClass*)pCFather);	// cast const type to none_const type
	VerifyBaseFuncConst((const BaseClass*)pFather); // cast none_const type to const type
	VerifyDerivedFunc((DerivedClass *)pFather);		// downward cast
	VerifyDerivedFuncConst((const DerivedClass *)pCFather);		// downward cast

	//funcptrArray[0] = &doSmoething();		// syntax error,funcptrArray only accept FuncPtr pointer;
	funcptrArray[0] = (FuncPtr)&doSmoething;	// right
	for (int iloop1 = 0; iloop1 < 10;iloop1 ++)
	{
		std::cout << *funcptrArray[iloop1] << " ," ;
	}
	std::cout << std::endl;




	// CPP cast
	// static_cast/const_cast/dynamic _cast/reinterpret_cast
	std::cout << std::endl << "******* CPP cast ******" <<std::endl;
	numC = static_cast<double>(numA)/numB;
	std::cout << "double type numC = " << numC << std::endl;

	
	VerifyBaseFunc(const_cast<BaseClass*>(pCFather));	// cast const type to none_const type
	VerifyBaseFuncConst(const_cast<const BaseClass*>(pFather)); // cast none_const type to const type
	VerifyDerivedFunc(dynamic_cast<DerivedClass *>(pFather));		// downward cast
	VerifyDerivedFuncConst(dynamic_cast<const DerivedClass *>(pCFather));		// downward cast
	// CPP dynamic_cast need a virtual member in the base class as a downward necessary flag
	funcptrArray[1] = reinterpret_cast<FuncPtr>(&doSmoething);
	for (int iloop1 = 0; iloop1 < 10;iloop1 ++)
	{
		std::cout << *funcptrArray[iloop1] << " ," ;
	}
	std::cout << std::endl;
	


	getchar();
	return;
}

验证结果

其余子程序

基类声明头文件

#ifndef BASECLASS_H
#define BASECLASS_H


class BaseClass
	{
	public:
		void FuncPub();

	private:
		void FuncPri();
		virtual void FuncPri2() = 0; // this virtual function is necessary for dynamic_cast

	};


#endif

基类实现源文件

#include "BaseClass.h"


void BaseClass::FuncPri()
{
	return;
}

void BaseClass::FuncPub()
{
	return;
}

派生类声明头文件

#ifndef DERIVEDCLASS_H
#define DERIVEDCLASS_H
#include "BaseClass.h"

class DerivedClass : public BaseClass
{

	void DerivedClass::FuncPri2();

};

#endif

派生类实现源文件

#include "DerivedClass.h"

void DerivedClass::FuncPri2()
{
	return;
}

验证函数声明头文件

#ifndef VERIFYFUNC_H
#define VERIFYFUNC_H

#include "BaseClass.h"
#include "DerivedClass.h"

void VerifyBaseFuncConst(const BaseClass *pCBobj );
void VerifyBaseFunc(BaseClass *pBobj);
void VerifyDerivedFuncConst(const DerivedClass *pCDobj);
void VerifyDerivedFunc(DerivedClass *pDobj);

#endif

验证函数实现源文件

#include "VerifyFunc.h"
#include <iostream>

void VerifyBaseFuncConst(const BaseClass *pCBobj )
{
	std::cout << "VerifyBaseFuncConst execute successful!!" << std::endl;
	return;
}
void VerifyBaseFunc(BaseClass *pBobj)
{
	std::cout << "VerifyBaseFunc execute successful!!" << std::endl;
	return;
}
void VerifyDerivedFuncConst(const DerivedClass *pCDobj)
{
	std::cout << "VerifyDerivedFuncConst execute successful!!" << std::endl;
	return;
}
void VerifyDerivedFunc(DerivedClass *pDobj)
{
	std::cout << "VerifyDerivedFunc execute successful!!" << std::endl;
	return;
}