使用类(3)

转换构造函数和转换函数

//head.h

#pragma once

#ifndef _CLASS_H_
#define _CLASS_H_

class Stonewt
{
private:
	enum {Lbs_per_stn = 14}; // static Lbs_per_stnd = 14
	int stone;
	double pds_left;
	double pounds;
public:
	Stonewt(double lbs); // 是接受一个参数的构造函数 -- 转换构造函数
	Stonewt(int stn, double lbs);
	Stonewt();
	~Stonewt();
	void show_lbs()const;
	void show_stn()const;
	// 转换函数
	explicit operator int()const;   // 必须要显示使用该转换函数 -- 加上了explicit
	operator double()const;
};



#endif


// fuc.cpp

#include"head.h"
#include<iostream>
using std::cout;

Stonewt::Stonewt(double lbs)
{
	stone = int(lbs) / Lbs_per_stn;     //  强制类型转换： int (lbs) 和 (int) lbs 效果相同
	pds_left = (int)lbs % Lbs_per_stn;
	pounds = lbs;
}

Stonewt::Stonewt(int stn, double lbs)
{
	stone = stn;
	pds_left = lbs;
	pounds = stn * Lbs_per_stn + lbs;
}

Stonewt::Stonewt()
{
	stone = pounds = pds_left = 0;
}

Stonewt::~Stonewt()
{

}

void Stonewt::show_stn()const
{
	cout << stone << " stone, " << pds_left << " pounds" << std::endl;
}

void Stonewt::show_lbs()const
{
	cout << pounds << " pounds" << std::endl;
}

// 转换函数的定义

Stonewt::operator int()const
{
	return int(pounds + 0.5); //实现返回整数型的四舍五入
}

Stonewt::operator double()const
{
	return pounds;
}


// main.cpp

//1.转换构造函数:本质上就是只接受一个参数的构造函数
// 原理：构造函数在进行构造时会创建一个类对象副本来赋值，最后返回这个副本
// 使用：Stonewt inconito = 275 -- 利用了单参数构造函数来进行初始化 相当于 Stonewt inconito = Stonewt(275) 和 Stonewt inconito(275)

//2.转换函数: 语法： operator typename() 
// 转换函数声明在类中，没有参数，也没有返回类型，但是在函数的定义中必须要有返回值，且这个返回值的类型与typename相同

//3. explicit可以可以关闭自动转换的特性，使得上述的两种转换函数必须要显示使用才可以发挥作用(explicit加在类的函数声明前即可)

#include"head.h"
#include<iostream>

int main()
{
	using std::cout;
	using std::endl;
	Stonewt pounds2(9, 2.8);
	Stonewt pounds1 = 15; //利用只有一个参数的构造函数来进行初始化 -- 即转换构造函数
	double p_wt = pounds2;  // 利用转换函数将类对象赋值给了double类型的变量
	cout << "pound1: " << endl;
	pounds1.show_lbs();
	pounds1.show_stn();
	pounds1 = 20; //利用转换构造函数
	cout << "After changing: " << endl;
	pounds1.show_lbs();
	pounds1.show_stn();
	cout << "pounds2(double):" << endl;
	cout << "p_wt = " << p_wt << endl;
	cout << "After convert to int:" << endl;
	cout << "p_wt = " << (int)p_wt << endl;

	long num = pounds2; 
	//若此处的int转换函数没有被设置为explicit, 则编译器会报错，因为int和double型的转换都可以将pounds2赋给num，会出现二义性
	//但若给int转换函数的类声明处加上了explicit,则必须显式调用该转换函数，所以此处会自动调用double转换函数
	


	system("pause");
	return 0;
}

//1.转换构造函数:本质上就是只接受一个参数的构造函数
// 原理：构造函数在进行构造时会创建一个类对象副本来赋值，最后返回这个副本
// 使用：Stonewt inconito = 275 -- 利用了单参数构造函数来进行初始化 相当于 Stonewt inconito = Stonewt(275) 和 Stonewt inconito(275)

//2.转换函数: 语法： operator typename()   -- 重载运算符: returntype operatorop()
// 转换函数声明在类中，没有参数，也没有返回类型，但是在函数的定义中必须要有返回值，且这个返回值的类型与typename相同

//3. explicit可以可以关闭自动转换的特性，使得上述的两种转换函数必须要显示使用才可以发挥作用  (explicit加在类的函数声明前即可)

//4.long num = pounds2; 
//若此处的int转换函数没有被设置为explicit, 则编译器会报错，因为int和double型的转换都可以将pounds2赋给num，会出现二义性
//但若给int转换函数的类声明处加上了explicit,则必须显式调用该转换函数，所以此处会自动调用double转换函数