C++知识点复习 ---- 类型转换函数

一.C语言中的类型转换

1.标准数据类型之间会进行隐士的类型安全转换
2.转换规则如下：

二.普通类型与类类型之间转换

普通类型到类类型示例：

#include<iostream>
#include<string>
using namespace std;
class Test
{
public:
	Test()
	{
	}
	Test(int i)
	{
	}
};
int main()
{
	Test t;
	//t=(Test)5;Test类中没有定义构造函数的时候报错
	//t=5;
	t=Test(5);//Test类中有定义构造函数的时候不报错调用构造函数生成临时变量对象
	t=5; //等价，隐式类型转换，调用转换构造函数
return 0;
}

再论构造函数
构造函数可以定义不同类型的参数
参数满足下列条件时成为转换构造函数

• 有且仅有一个参数
• 参数是基本类型
• 参数是其他类类型

另一个视角
旧式的C语言方式强制类型转换

int i;
Test t;
i=(int)(1.5); //将1.5强制转换成int型
t=Test(100); //将100整形数强制转换成类类型，本质为调用了构造函数

编译器会尽力尝试让源码通过编译
Test T；
T=100；
100这个立即数默认为int类型，怎么可能赋值给T对象？现在就报错吗？不急，编译器会去看看有没有转换构造函数，OK，发现Test类中定义了Test（int i）可以进行转换，默认等价于T=Test(100)

编译器尽力尝试的结果是隐式类型转换
隐式类型转换
1.会程序以意想不到的方式进行工作
2.是工程中bug的重要来源

#include<iostream>
#include<string>
using namespace std;
class Test
{
	  int mValue;
public:
	Test()
	{
		mValue=0;
	}
	Test(int i)  //转换构造函数
	{	
		mValue=i;
	}
	Test operator +(const Test& p)
	{
		Test ret(mValue+p.mValue);
		return ret;
	}
	int value()
	{
		return mValue;
	}
};
int main()
{
	Test t;
	t=5; //t=Test(5)
	Test r;
	r=t+10;//等价于：r=t+Test(10);隐式类型转换。结果为15
	cout<<r.value()<<endl;
	return 0;
}

编译器的行为
1.工程中通过explicit关键字杜绝编译器的转换尝试
2.转换构造函数被explicit修饰时只能进行显示转换
转换方式：

static_cast(value); //C++中推荐
className(value); //手工调用构造函数
(className)value; //不推荐

#include<iostream>
#include<string>
using namespace std;
class Test
{
	  int mValue;
public:
	Test()
	{
		mValue=0;
	}
	explicit Test(int i)
	{	
		mValue=i;
	}
	Test operator +(const Test& p)
	{
		Test ret(mValue+p.mValue);
		return ret;
	}
	int value()
	{
		return mValue;
	}
};
int main()
{
	Test t;
	//t=(Test)5; //手工进行强制类型转换，不推荐
	t=static_cast<Test>(5);
	Test r;
	//r=t+(Test)10;
	//r=t+Test(10);
	r=t+static_cast<Test>(10);
	cout<<r.value()<<endl;
	return 0;
}

总结：
转换构造函数只有一个参数
转换构造函数的参数类型是其他类型
转换构造函数在类型转换时被调用
隐式类型转换是工程中bug的重要来源
explicit关键字用于杜绝隐式类型转换。

三. 类类型通过类型转换到普通类型

#include<iostream>
#include<string>
using namespace std;
class Test
{
	  int mValue;
public:
	Test(int i=0)
	{	
		mValue=i;
	}
	int value()
	{
		return mValue;
	}
};
int main()
{
	Test t;
	int i=(int)t;
	return 0;
}
编译报错

类型转换函数
C++类中可以定义类型转换函数
类型转换函数用于将类对象转换为其他类型
语法规则：

operator Type()
{
	Type ret;
	...
	return ret;
}

函数改写：

#include<iostream>
#include<string>
using namespace std;
class Test
{
	  int mValue;
public:
	Test(int i=0)
	{	
		mValue=i;
	}
	int value()
	{
		return mValue;
	}
	operator int()
	{
		return mValue;
	}	
};
int main()
{
	Test t(100);
	int i=t; //int i = t.operator int(); 隐式调用
	cout<<"t.value()="<<t.value()<<endl;
	cout<<"i="<<i<<endl;
	return 0;
}
编译结果：
t.value()=100
i=100

类型转换函数：

• 与转换构造函数具有同等的地位
• 使得编译器有能力将对象转换成其他类型
• 编译器能够隐式的使用类型转换函数

编译器会尽力尝试让源码通过编译

Test t(1);
int i=t;

t这个对象为Test类型，怎么可能用于初始化int类型的变量呢，现在就报错吗？不急，先看看有没有类型转换函数。发现Test类中定义了operator int()，可以进行转换。

四.类类型之间的相互转换

#include<iostream>
#include<string>
using namespace std;
class Test; //前置声明，方便Value调用
class Value
{
public:
	Value()
	{
	}
	explicit Value(Test& t)
	{
	}
};
class Test
{
	  int mValue;
public:
	Test(int i=0)
	{	
		mValue=i;
	}
	int value()
	{
		return mValue;
	}	
	operator Value() //将Test类的对象转换为Value类的对象
	{
		Value ret;
		cout<<"operator Value()"<<endl;
		return ret;
	}
};
int main()
{
	Test t(100);
	
//Value类中无转换构造函数Value(Test &)时，operator Value()存在。
//	Value v=t; //等价于Value v=t.operator Value();
	
//Value类存在转换构造函数Value(Test &)时，operator Value()不存在。
	Value v=t; //等价于Value(t)

//Value类存在转换构造函数Value(Test&)时，operator Value()存在--》报错。解决方法在转换构造函数之前加explicit关键字。
	cout<<"t.value()="<<t.value()<<endl;
	return 0;
}
operator Value()
t.value()=100

无法抑制隐式的类型转换函数调用
类型转换函数可能与转换构造函数冲突
工程中以Type toType()的公有成员代替转换构造函数

Value toValue()
{
	Value ret;
	cout<<"operator Value()"<<endl;
	return ret;
}

总结：
C++类中可以定义类型转换函数
类型转换函数用于将类对象转换为其他类型
类型转换函数与转换构造函数具有同等的地位
工程中以Type toType()的公有成员代替类型转换函数。