C++之转换函数(convertion function)

代码乌龟

已于 2022-04-05 11:41:01 修改

阅读量2.8k

点赞数

分类专栏： C/C++ 文章标签： c++ visual studio 转换函数

于 2022-03-13 13:30:44 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_43744293/article/details/123448116

版权

C/C++ 专栏收录该内容

28 篇文章

订阅专栏

一类转换为其他类型

类转换为其他类型，这里的其他类型可以是任何类型，如int、double甚至是你定义的一个类，至于怎么写，就是设计的人的事情了。

下面我以转换为double型为例，请看下面的例子：

#include <iostream>
#include <string>

using namespace std;

class Fraction
{
public:
	Fraction(int num, int den = 1)
		:numerator(num), denominator(den){}

	operator double() const
	{
		return ( numerator*1.0 / denominator);
	}

	operator string() const
	{
		return to_string(numerator) + '/'+ to_string(denominator);
	}

private:
	int numerator;//分子
	int denominator;//分母
};
int main()
{
	/*********************************************/
	Fraction f(3,5);
	
	double d = f + 4.3;//f转换为double
	cout << d << endl;

	string s = f;//f转换为string
	cout << s << endl;


	system("pause");
	return 0;
}

注意上面：operator double() const和operator string() const就是两个转换函数。其语法是：operator type()。它不需要参数，也不要返回值，返回值type实际上就已经决定了。(注，const只是把成员函数变为常量成员函数)。
运行结果如下：
在这里插入图片描述

智能指针中的一个例子

使用智能指针时，有这样一种方法，如下

std::shared_ptr<int> ptr = std::make_shared<int>(20);
if(ptr)
	std::cout<<"ptr is not empty."<<std::endl;

这里为什么可以直接对ptr判断是否为空呢？其实就是用了转换函数。其大概的实现如下：

template<typename T>
class SmartPointer {
private:
    T* _ptr;
    size_t* _count;
public:
/******其他成员函数*******/
	operator bool() const
	{
		if(ptr) return true;
		else return false;
	}
};

二 non-explicit one argument 构造函数

one argument的意思是我们只要给一个参数就行，尽管它实际的形参可能有多个。

还以上面的例子为基础，其实构造函数Fraction(int num, int den = 1)就是转换函数，其特点是只传一个参数，其他参数使用默认。

测试如下：

int main()
{
/*****************这里同上********************/
	Fraction f1 = f + 4.3;
	cout << f1 << endl;

	system("pause");
	return 0;
}

在上面中：

f先转换为double型，
然后和4.3相加，结果为4.9
最后4.9作为参数传入Fraction的类构造函数，也即执行double到Fraction的转换

打印的结果很明显就是4。因为虽然传入的是4.9，但是由于构造的参数是整型，转换后为4。

请思考：这里为什么不是先把4.3转换为Fraction类类型？
其实很简单，因为我们并没有定义Fraction的加法，所以编译器在转换时，这条路是走不通的。

三.别让编译器帮你做选择

前一节的最后部分我给了一个思考，并给出了原因。现在我们来定义一个Fraction的加法，即重载+,且是做成员函数，像下面这样：

#include <iostream>
#include <string>

using namespace std;

class Fraction
{
	/**************这里同上**********/
	Fraction operator+(const Fraction& f)
	{
		return Fraction(this->numerator * f.denominator + this->denominator * f.numerator,
			f.denominator * this->denominator);
	}
	/**************这里同上**********/
};
int main()
{

	Fraction f(3,5);
	double d = f + 4.3;
	Fraction f1 = f + 4.3;


	system("pause");
	return 0;
}

编译时你会发现这样会报错：“Fraction::operator +”: 2 个重载有相似的转换。原因是在做加法时，有两种选择：将f转为double类型再加和将4.3转为Fraction类型再加。

可是我们知道，编译器是做不了选择的，当面临多种选择时，编译器只能报错。解决方法是：

或者将转换函数operator double()删掉，此时显而易见，double d = f + 4.3;会报错。因为此时f + 4.3是一个Fraction类类型，赋值时无法将Fraction转为double。
或者再构造函数前加上关键字explicit,这样旨在告诉编译器，不要给我做其他类型到Fraction类类型的转换。此时Fraction f1 = f + 4.3;会报错，原理和上面的相同，不再赘述。