C++面向对象程序设计习题1：分数相加

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/*
 * 实现分数相加
 * 分子分母均为无符号整数
 * 单独有一位char类型的成员表示正负号
 */


#ifndef _FRACT_HPP_
#define _FRACT_HPP_

#include <iostream>

using uint_t = unsigned int;

class Fract
{
private:
    uint_t fenzi, fenmu; // 分子分母均为正数表示
    char sign; // 正负号，默认为'+'

    uint_t gcd(uint_t, uint_t) const; // 最大公约数
    uint_t lcm(uint_t, uint_t) const; // 最小公倍数
public:
    explicit Fract(uint_t a = 0, uint_t b = 1, char s = '+'); // 构造函数参数默认值写入函数声明中,且使用explicit禁用复制初始化
    
    void add(const Fract&);
    void sub(const Fract&);
    Fract operator+(const Fract&) const;
    Fract operator-(const Fract&) const;
    void show() const;
};

// 构造函数，检查分子分母是否最简
Fract::Fract(uint_t a, uint_t b, char s) : fenzi(a), fenmu(b), sign(s)
{
    uint_t init_gcd = gcd(fenzi, fenmu);
    // 将分子分母化为最简
    if (init_gcd != 0) {
        fenzi = fenzi / init_gcd;
        fenmu = fenmu / init_gcd;
    }
}

// 最大公约数
uint_t Fract::gcd(uint_t m, uint_t n) const
{
    uint_t k = m < n ? m : n;
    for (; k > 0; --k) {
        if (m % k == 0 && n % k == 0) {
            break;
        }
    }
    return k;
}

// 最小公倍数: 两数相乘后除以最大公约数
uint_t Fract::lcm(uint_t m, uint_t n) const
{
    return m * n / gcd(m, n);
}

// 分数加法
void Fract::add(const Fract& x)
{
    uint_t init_lcm = lcm(this->fenmu, x.fenmu);

    int temp_fenzi;
    // 如果x符号为-，则分子相减
    if (x.sign == '+') {
        temp_fenzi = this->fenzi * init_lcm / this->fenmu + x.fenzi * init_lcm / x.fenmu;
    } else {
        temp_fenzi = this->fenzi * init_lcm / this->fenmu - x.fenzi * init_lcm / x.fenmu;
    }

    if (temp_fenzi < 0) {
        // 结果为-，则修改符号为-
        this->fenzi = temp_fenzi * -1;
        this->sign = '-';
    } else {
        this->fenzi = temp_fenzi;
        this->sign = '+';
    }
    
    this->fenmu = init_lcm;
    
    // 将分子分母化为最简
    uint_t init_gcd = gcd(fenzi, fenmu);
    if (init_gcd != 0) {
        fenzi = fenzi / init_gcd;
        fenmu = fenmu / init_gcd;
    }
}

// 分数减法
void Fract::sub(const Fract& x)
{
    char s = x.sign == '+' ? '-' : '+'; // 获取x的相反符号
    Fract y(x.fenzi, x.fenmu, s);
    this->add(y);
}

// 运算符+重载
Fract Fract::operator+(const Fract& x) const
{
    Fract z(this->fenzi, this->fenmu, this->sign);
    z.add(x);
    return z;
}

// 运算符-重载
Fract Fract::operator-(const Fract& x) const
{
    Fract z(this->fenzi, this->fenmu, this->sign);
    z.sub(x);
    return z;
}

// 分数显示
void Fract::show() const
{
    char s = this->sign == '+' ? ' ':'-';
    if (fenzi % fenmu == 0) {
        std::cout << s << fenzi / fenmu << std::endl;
    } else {
        std::cout << s << this->fenzi << '/' << this->fenmu << std::endl;
    }
}



#endif


/*
// 测试
#include "Fract.hpp"
#include <iostream>

using namespace std;

int main()
{
    Fract a(1, 5), b(7, 8, '-');
    a.show();
    b.show();
    // 分数加法
    Fract c = a + b;
    c.show();
    // 分数减法
    c = a - b;
    c.show();
    return 0;
}
 */