类特性

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
1.cpp
class Time
{
	int hours;
	int minuates;
public:
	Time(int h,int m);
	Time();
	Time operator+(const Time &) const;
	Time operator-(const Time &) const;
	Time operator*(double) const;
	void show() const;

};

2.cpp
#include"1.h"
#include<iostream>


Time::Time()
{
	hours = 0;
	minuates = 0;
}

Time::Time(int h , int m )
{
	hours = h;
	minuates = m;

}
Time Time::operator+(const Time & a) const
{
	Time temp;
	int totalm = a.minuates + minuates;
	temp.minuates=totalm % 60;
	temp.hours = a.hours + hours + totalm / 60;
	return temp;//temp 拷贝到指定的内存或是寄存器，调用程序可访问到的位置 当函数执行完temp还是会消失的 不可以使用引用的原因在此
}
Time Time::operator-(const Time &a) const
{
	Time t;
	int ta = hours * 60 + minuates;
	int tb = a.hours * 60 + a.minuates;
	int temp = tb - ta;
	t.minuates = temp % 60;
	t.hours = temp / 60;
	return t;
}
Time Time::operator*(double x) const
{
	Time t;
	int result = (hours * 60 + minuates)*x;
	t.hours=result / 60;
	t.minuates = result % 60;
	return t;
}

void Time::show() const
{
	std::cout << hours << ":" << minuates << std::endl;
}
3.cpp
#include "stdafx.h"

#include"1.h"
#include<iostream>
int main()
{
	Time t1(1, 12);
	Time t2{ 2,33 };
	Time t3 = t1 + t2;
	t3.show();
	t3 = t1 - t2;
	t3.show();
	t3=t2*1.5;
	t3.show();
	std::cin.get();
    return 0;
}

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#ifndef STONE_H
#define STONE_H

#include<iostream>
namespace STONE
{


	class Stone
	{
		//enum{Lbs_to_stn=14};
		static const int Lbs_to_stn = 14;
		double pounds;
		int  stone;
		double pfs_left;
	
	public:
		
		Stone();
		Stone(int, double);
		Stone(double);
		friend std::ostream & operator<<(std::ostream &, const Stone &);

	};
}
#endif
using namespace STONE;


namespace STONE
{

	Stone::Stone()
	{
		stone = pfs_left = pounds = 0;
	
	}
	Stone::Stone(int m, double n)
	{
		stone = m;
		pfs_left = n;
		pounds = m*Lbs_to_stn + pfs_left;
	}
	Stone::Stone(double m)
	{
		pounds = m;
		pfs_left =int (m )% Lbs_to_stn;
		stone = m/Lbs_to_stn;
	}
	 std::ostream & operator<<(std::ostream & os, const Stone & ob)
	{
		 using std::cout;
		 using std::endl;
		 cout << "仅用一个数值来表示：" << endl;
		 os << ob.pounds << endl;
		 cout << "另一种表示方法：" << endl;
		 os << ob.pfs_left << " " << ob.stone << endl;
		 return os;
	}
}

#include"stone.h"

using STONE::Stone;
void display(Stone  m, int n);

int main()
{
	using std::cout;
	
	Stone s1 = 1222;//先变为double 再变为Stone 自动类型转化 编译器尽最大可能来保持程序的运行（多次转换）
	Stone s2(1, 1.3);
	Stone s3(33.222);
	Stone s4 = Stone(222);
	cout << s1;
	display(33.22, 2);//隐式类型转化 临时对象 
	std::cin.get();
    return 0;
}

void display(Stone  m, int n)
{
	std::cout << m;//cout 和 Stone 对象 查找运算符函数 是这两个参数类型的 友元函数不是类内部函数
}

1
2
3
4
5
6
7
explicit operator double();
Stone::operator double()
{
	return pounds;
 }
 int x = int(s4);//由于使用了explicit使得 编译器不会进行自动类型转化，必须明确指出待转换类型