C++类型转换详解

编辑: admin 分类: c#语言 发布时间: 2021-12-12 来源:互联网
目录
  • 内置类型的转换
  • 自定义类型转换
    • explicit 关键字
      • 提醒
    • 提问：编译器在什么时候使用Stone(double)?
    • 转换函数
      • 概念介绍
        • 自动引用类型转换
          • 缺陷
      • 总结

        C++对于内置类型有隐式或显式的类型转化，如int,double,long,char，但是，C++还有类这个概念，类是一种自定义类型，为了让类（自定义类型）达到内置类型的层次，C++对类也挺提供一些方法进行自动或者强制类型转换
        C++的好多工作，在我看来就是让自定义类型能和内置类型一样简单使用、操作。

        内置类型的转换

            int a = 8;
	double b = 4.4;
	long c = a;//隐式类型转换
	long d = (long)b;//显式类型转换

        这都是我们熟悉的，是编译器已经帮我们处理好了的。

        自定义类型转换

        对于自定义类型，其类型转换，都是我们可以自己实现，自己控制的。

        /*
* 对石块类的 声明定义
*/
class Stone
{
public:
	Stone(double weight);
	Stone(int stone_type, double volume);
private:
	int _stone_type;
	double _weight;
	double _volume;
};
Stone::Stone(double weight)
{
	_stone_type = 1;
	_weight = weight;
	_volume = 10.5;
}
Stone::Stone(int stone_type, double volume=10.5)
{
	_stone_type = stone_type;
	_weight = 5.8;
	_volume = volume;
}

        我们提供了Stone(double) 这个构造函数的重载，可以直接将double类型进行构造出一个类。

        	Stone s1 = 24.5;
	Stone s2(10.5);
	Stone s3(21, 20.5);

        对于Stone s1 = 24.5;而言，重新是由构造函数Stone(double)来创建一个临时的Stone对象，并将24.5作为初始值，随后，采用逐成员复值的方法，将该临时对象的内容复制到s1对象中。也就是将一个double类型的对象转换为Stone类型的对象。

        这一过程称为隐式转换，它是自动进行的，不需要显式迁至类型转换。

        注意：只有接受一个参数的构造函数才能作为转换函数，

        像Stone(int stone_type, double volume)有两个参数，因此不能用来转换类型，然而，如果它第二代参数是个缺省，提供了默认值，其便可以用来进行int对象的转换。
        这个转换函数是将那些其他（内置或者其他的类型）类型向类类型转换

        explicit 关键字

        将构造函数用作于自动类型转换函数似乎是一项不错的特性，但是这种自动转换的并不是在所有情况下都需要，某些情况下，不需要这种转换，但是却意外的进行了转换。

        所以C++提供了关键字explicit,用于关闭这种自动转换。

        explicit的意思是：显式的，明确的。

        可以加在函数声明前

        explicit Stone(double weight)

        这样，只能显式调用这个构造。

        在这里插入图片描述

        Stone s1 = Stone(24.5);
Stone s4 = (Stone)19.99;//非常像内置类型的显式转换

        这样显式调用就没什么问题。

        提醒

        还有一个要提醒的：如果像这个一样，

        在这里插入图片描述

        有两个参数的函数，

        在这里插入图片描述

        有一个加了explicit，另一个没加，如果还像刚才一样，隐式转换的那种，还是能泡过的，因为，会执行两个参数的构造函数，因为就这个是能匹配的，这肯会造成一个隐患，给大家提个醒，要加explicit，构成重载的函数最好都加上，不然出来Bug就不好找了。

        提问：编译器在什么时候使用Stone(double)?

        如果在声明中使用了关键字explicit，则Stone(double)将只能用于显式强制类型转换，
        如果没有的话，就还能用于隐式类型转换

        • 将Stone对象初始化为double值时，例：Stone s1 = 24.5;
        • double值赋给Stone对象，例：Stone s5;s5 = 19.7;
        • 将double值传递给接受Stone参数的函数，例：
        void Print(const Stone& tmp) 
{cout << "Print" << endl;}
Print(19.7);
        • 返回值被声明为Stone类型的函数试图返回double。
        • 在上述任意一种情况下，使用可转换为double类型的内置类型时（只要能转换成double类型的内置类型对象，都能这样隐式调用）
            Stone s5;
	s5 = 19;
	Stone s6(100);

        同时，要记住编译器不能处理具有二义性的调用。

        转换函数

        概念介绍

        上面也介绍过转换函数，

        不过那是内置类型转换为类类型，
        这里的是类类型转换为内置类型。

        转换函数的形式：operator typeName();

        1.转换函数必须是类方法

        2.转换函数不能指定返回类型

        3.转换函数不能有参数

        例如：转换为double类型的函数原型：

        operator double();

        typeName（这里指 double ，因此就不需要指定返回类型。转换函数是类方法意味着：它需要类对象来调用，从而告知函数要转换的值。因此，函数不需要函数。

        Stone::operator double() const
{
	return _weight;
}

Stone s4 = (Stone)19.99;
double d1 = s4;//隐式调用
double d2 = (double)s4;//显式
double d3 = double(s4);//显式

        且这调用的都是转换函数。

        自动引用类型转换

        像

        double d1 = s4;//隐式调用

        都是自动转换。

        还有赋值的情况，可能会存在内置类型之间的转换。

        long l1 = s4;

        这里可没有long的转换函数，说明是转化为double后，又转换为了long类型。

        缺陷

        转换函数都存在缺陷。

        提供自动调用、隐式转换的函数存在的问题：使用者不希望转换时，转换函数也可能进行了转换。

        所以最好还是要加上explicit,只有显式调用时，才能进行转换。

        或者，使用一些功能相同的类方法来继续代替，这样，如果类成员又类型一样的也能转换。

        double Stone::Stone_to_double_weight(void)
{
	return _weight;
}
double Stone::Stone_to_double_volume(void)
{
	return _volume;
}

        我觉得这玩意比那个还好用一些。

        总结

        应谨慎使用隐式转换函数。通常，最好选择仅在被显式调用时才会执行的函数

        C++为类提供了下面的类型转换

        • 只有一个参数的类构造函数用于将类型与该参数相同的值转换为类类型。
        • 被称为转换函数的特殊类成员运算符函数，用于将类对象转换为其他类型，转换函数是类成员，没有返回类型，没有参数，名为operator typeName();

        本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注海外IDC网的更多内容!

        【本文由：http://www.nextecloud.cn/flb.html提供，感谢】
        更多阅读