类类型与基本数据类型的转换_#include using namespace std; class rmb

构造函数用作类型转换

通过 “构造函数用作类型转换” 可以实现基本数据类型转换为类类型

几个前提和注意

前提：

1. 此类一定要有一个只带一个参数的构造函数

注意 ：

1. 转换是隐式¹的
2. 只能由参数类型（基本数据类型）向类类型的转换

演示代码

#include <iostream>
using namespace std;
class A
{public:
	A()
		{x=0;}
	A(int a)
		{x=a;}
	int x;
};
A f(A a)					//f函数的定义，形参是A类对象（我们在后面给它的形参赋值一个int类型的数据看看）
{
	return a;               //返回一个A类型的数据
}
int main()
{
	f(1);
	/****************************************
	这里进行f调用时先构造了一个A类对象
	隐式调用了   A::A(int)   进行隐式转换
	（将int类的实参转换为A类的形参），
	转换后将实参传与f函数形参
	*****************************************/
	//cout<<"转换成功？结果为"<<f(1)<<endl;
	/******************************************
	输出f(1)的结果，因为未重载输入输出流，
	所以cout不能直接输出A类对象f(1)，这里
	的cout语句不能编译成功。
	*****************************************/
	cout<<"转换成功，结果为一个A类的对象，对象的数据成员x的值为:"<<f(1).x<<endl;	//输出成功
}

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
29
30
31
32

输出结果如下：

类类型转换函数

本函数用作将类类型向基本类型转换

1. 在类定义体中声明

    	operator type( );
   1

① 其中type为：要转换的基本类型名。
② 此函数既没有参数，又没有返回类型，但在函数体中必须返回具有type类型的一个对象。

2. 定义转换函数的函数体

类名::operator type()
{
	...
	return type类型的值;
}
1
2
3
4
5

3. 使用类型转换函数
   ①使用类型转换函数与对基本类型进行强制转换时一样，就像是一种函数调用过程
   ②

演示代码

#include <iostream>

using namespace std;

class A
{
    int x;
    char* p;
public:
    A(int a)
    {
        x=a;
        p=new char[50];
        p="A类型中的char类型，这是带参数的构造函数的输出结果";
    }
    A()
    {
        x=0;
        p=new char[50];
        p="A类型中的char类型，这是不带参数的构造函数的输出结果";
    }
    operator char* ();//类类型转换函数，返回一个char类型的指针
};
A::operator char* ()
{
    return p;//这里的p是A类型中的char类型指针，对应本函数的返回类型char。
}
int main()
{
    A a(10);
    A b;
    cout<<a<<endl<<"---------------------------------------------------"<<endl<<b<<endl;
}
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
29
30
31
32
33

类类型转换的目的是什么？

方便对 对象 不需要通过转换 而直接操作。

演示代码

#include <iostream>

using namespace std;

class RMB
{
public:
    RMB(double value=0.0)//这个构造函数就是把基本的数据类型转换为类类型，
    {   yuan=value; jf=(value-yuan)*1000000+0.5; }
    //jf用于确认小数点之后的精度
    //yuan，代表整数部分
    //jf，代表小数部分
    //将整数部分赋值给yuan，小数点之后的6位赋值给jf，再判断第七位是否大于等于0.5，是的话给jf加1
    //得到一个RMB对象，由整数部分yuan和小数部分jf组成

    operator double()//调用一个对象参与特定的运算就会隐式调用这个函数返回一个规定的数据类型给对象。
    {return yuan+jf/1000000.0;}
    //RMB类转基本类型，返回的是一个double型数据，
    //由两个RMB中带有的数据计算所得

    void display()
    {cout<<(yuan+jf/1000000.0)<<endl;}
protected:
    unsigned int yuan;
    unsigned int jf;
};
int main()
{
    RMB d1(2.121234556),d2(1.515),d3;
    d3=RMB((double)d1+(double)d2);//强制类型转换d1、d2，但d1、d2的原本数据类型不变
    d1.display();d2.display();
    d3=d1+d2;
    //d1+d2的操作是double类型数据相加，再是转为RMB类赋值给d3
    d3.display();
}

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
29
30
31
32
33
34
35
36