C++语法15-类型转换

发表于 | 更新于: | 分类于 | | 热度: ℃
字数统计: 1.7k字 | 阅读时长 ≈ 6分钟

1. 系统预定义类型间的转换

类型转换是将一种类型的值转换为另一种类型值。对于系统预定义的标准类型（如int、float、double、char等），C++提供两种类型转换方式：一种是隐式类型转换；另一种是显示类型转换。

1.1 隐式类型转换

隐式类型转换主要遵循以下规则：

（1）在赋值表达式A=B的情况下，赋值运算符右端B的值需要转换为A类型进行赋值。

（2）当char或short类型变量与int类型变量进行运算时，将char或short类型转换成int类型。

（3）当两个操作对象类型不一致时，在算术运算前，级别低的类型自动转换为级别高的类型。

1.2 显示类型转换

编程人员在程序中可以明确地指出将一种数据类型转换成另一种指定的类型，这种转换成为显示类型转换。

2. 类类型与系统预定义类型间的转换

对于用户自己定义的类类型而言，如何实现它们与其他数据类型之间的转换呢？通常，可归纳为以下：
（1）通过转换构造函数进行类型转换。

（2）通过类型转换函数进行类型转换。

2.1 转换构造函数

转换构造函数也是构造函数的一种，它具有类型转换的作用，它的作用是将一个其他类型的数据转换成它所在类的对象。

通常，使用转换构造函数将一个指定的数据类型转换为类对象的方法如下：

（1）先声明一个类。

（2）在这个类中定义一个只有一个参数的构造函数，参数是待转换类型的数据，在函数体中指定转换的方法。

（3）可以用以下形式进行类型转换。

  类名（待转换类型的数据）

说明：

（1）转换构造函数也是一种构造函数，它遵循构造函数的一般规则。转换构造函数只有一个参数，作用是将一个其他类型的数据转换它所在类的对象。但是，有一个参数的构造函数不一定是转换构造函数，它可以是普通的构造函数，仅仅起对象初始化的作用。

（2）转换构造函数不仅可以将一个系统预定义的标准类型数据转换成类的对象，也可以将另一个类的对象转换成构造函数所在的类对象。（不做详解）

2.2 类型转换函数

通过转换构造函数可以将一个指定类型的数据转换为类的对象。但是不能反过来将一个类的对象转换成其他类型的数据，例如不能将一个Complex类的对象转换成double类型的数据。为此，C++提供了一个称为类型转换函数的函数来解决这个转换问题。类型转换的作用就是将一个类的对象转换成另一类型的数据。在类中，定义类型转换函数的一般格式为：

1
2
3
operator 目标类型（）{
	函数体
}

其中，目标类型为希望转换成的类型名，它既可以是预定义的标准函数也可以是其他类的类型。类型转换函数的函数名为“operator 目标类型”，在函数名前面不能指定函数类型，也不能有参数。通常，其函数体的最后一条语句是return语句，返回值的类型是该函数的目标函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//类型转换的应用
#include<iostream>
using namespaace std;

class Complex{
  public:
    Complex(double r=0,double i=0){
        real=r;
        imag=i;
    }
    operator double(){
        return real;
    }
  private:
    double real,imag;
};

int main(){
	Complex com(2.2,4.4);
    cout<<"Complex类的对象com转换成double型的数据为："；
    cout<<double(com)<<endl；

	return 0;
}

关于类型转换函数，有以下几点注意事项：

（1）类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。类型转换函数也可以在类体中声明函数原型，而将函数体定义在类的外部。

（2）类型转换函数既没有参数，也不能在函数名前面指定函数类型。

（3）类型函数中必须有return语句，即必须送回目标类型的数据作为函数的返回值。

（4）一个类可以定义多个类型转换函数。C++编译器将根据类型转换函数名自动地选择一个合适的类型转换函数予以调用。

2.3 转换构造函数和类型转换函数的综合应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<iostream>
using namespace std;
class Complex{
    public:
    	Complex(){}	//不带参数的构造函数
        Complex(int r,int i){	//带两个参数的构造函数
			real=r;imag=i;
        }
        Complex（int x){		//转换构造函数，将int类型
			real=imag=i/2;	
        }
        operator int(){
			return real+imag;
        }
    	void print(){ 
        	cout<<"real:"<<real<<"\t"<<"imag:"<<imag<<endl;
        }
    private:
    	int real,imag;
};
int main(){
    Complex a1(1,2),a2(3,4);
    Complex a3;
    a3=a1+a2;
    a3.print();
    
    return 0；
}

分析这个程序，读者一定会感到奇怪，类Complex中有没有定义将两个对象相加的运算符重载函数，怎么还可以进行“a1+a2”的操作呢 ？这是由于C++自动进行隐式转换的缘故。这个自动进行类型转换过程的步骤如下：

（1）寻找两个Complex类对象相加的运算符重载函数，程序中未找到。

（2）寻找能将Complex类的对象转换成int型数据的类型转换函数operator int()，程序中找到。于是调用其分别将 对象a1和a2隐式转换成int类型的数据3和7。

（3）寻找将两个整数相加的运算符函数，这个运算符函数已经在C++系统中预定义。于是调用这个运算符函数将两个int类型的数据3和7相加得到10。

（4）由于语句“a3=a1+a2;”的赋值号左边是Complex类的对象a3,而右边是int类型数据10，于是隐式调用转换构造函数将int类型数10转换成Complex类的一个临时对象（其real和image都是5），然后将这个临时对象的值赋给Complex类对象a3，执行结果是对象a3的real和image也分别是5。

-------------The End-------------
0%