学习C++——类的自动转换和强制类型转换

类的自动转换和强制类型转换

/*
本程序主要的用法是：
1、类型转换函数的定义以及使用。
（double类型赋值给对象类型，此时构造函数可以实现；
对象类型赋值给double类型，此时用转换函数来实现。）
2、成员函数实现加法的重载。
3、友元函数实现加法的重载。
*/
#ifndef STONEWT_H_
#define STONEWT_H_
class Stonewt
{
private:
enum {Lbs_per_stn = 14};//每14磅等于1英石
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;
/*
转换函数：因为上面可以知道，存在Stonewt wolfe(25.6);
也就是可以将一个double类型赋值给Stonewt对象，但是能否将
一个Stonewt对象赋值给一个double类型，即double host =？ wolfe;
这就需要用到转换函数了。转换函数的原型是：operator double();
operator int();转换函数是类方法，需要通过类对象来调用，从而告知函数要转换的值。
*/
//转换函数的声明
operator double () const;
operator int () const;
//使用成员函数
//Stonewt operator+(const Stonewt & st) const;

//使用友元函数来重载加法
friend Stonewt operator+(const Stonewt & st1, const Stonewt & st2);
};
#endif

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

Stonewt::Stonewt(double lbs)//构造函数
{
stone = int (lbs) / Lbs_per_stn;
pds_left = int (lbs) % Lbs_per_stn + lbs - int (lbs);
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_lbs() const//显示函数，显示磅
{
cout << pounds << " pounds\n";
}

void Stonewt::show_stn() const//显示函数，显示英石
{
cout << stone << " stone, " << pds_left << " pounds\n";
}

//转换函数的定义
Stonewt::operator double () const
{
return pounds;
}
Stonewt::operator int() const
{
return int (pounds + 0.5);
}
//使用成员函数重载加法
/*Stonewt Stonewt::operator+(const Stonewt & st) const
{
double pds = pounds + st.pounds;
Stonewt sum(pds);
return sum;
}*/
//使用友元函数重载加法

Stonewt operator+(const Stonewt & st1, const Stonewt & st2)
{
double pds = st1.pounds + st2.pounds;
Stonewt sum(pds);
return sum;
}

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

void display(const Stonewt & st, int n);

int main()
{
Stonewt incognito = 275;
Stonewt wolfe(287.7);
Stonewt taft(21, 8);

cout << "The incognito weighed ";
incognito.show_stn();
cout << "The wolfe weighed ";
wolfe.show_stn();
cout << "The taft weighed ";
taft.show_lbs();

incognito = 276.8;
/*
incognito = 276.8;使用接收double参数的构造函数，
将276.8转换为一个Stonewt值，这将把incognito的
pound成员设置为276.8。因为语句使用了构造函数，
所以还将设置shone,pds_left成员。
*/
taft = 325;
/*
将一个int值转换为double类型，然后使用Stonewt(double)
来设置全部3个成员
*/
cout << "\nincognito = 276.8;the incognito weighed ";
incognito.show_stn();
cout << "taft = 325;the taft weighed ";
taft.show_lbs();

cout << "\ndisplay(taft, 2);显示的结果：\n";
display(taft, 2);
cout << "\ndisplay(422, 2);显示的结果：\n";
display(422, 2);

/*
先将422，转换为一个double数，然后使用Stonewt(double)
将其转换为一个Stonewt对象。
*/
cout << "\n验证转换函数,定义了double变量poun:\n";
double poun;
poun = taft;
cout << "poun = taft = " << poun << "\n";
cout << "\n成员函数重载加法：\n";

Stonewt st1 (12.3);
Stonewt st2 (11.4);
Stonewt sum_st;
sum_st = st1 + st2;
/*
使用友元函数或者是使用成员函数实现加法重载，
但是不能同时定义两个函数，只能定义其中一个。
*/
cout << "sum_st = " ;
sum_st.show_lbs();
std::cin.get();
return 0;
}

void display(const Stonewt & st, int n)
{
for(int i = 0; i<n; i++)
{
cout << "wow! ";
st.show_stn();
}
}