fraction类的运算重载

重载>> 和  <<

#include <iosfwd> // 或 #include <iostream>
using std::istream;
using std::ostream;

friend istream& operator>> (istream& , Myclass& );
friend ostream& operator<< (ostream& , const Myclass& );

 

 

运算符重载举例

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
//fraction.h
#ifndef FRACTION_H
#define FRACTION_H
 
#include <iostream>
 
class Fraction
{
    friend std::ostream& operator<< (std::ostream& out, const Fraction& f);
    public:
        Fraction(long n=0, long d=1);
        virtual ~Fraction();
        Fraction operator- () const//重载负号(一元运算符重载)
        {
            return Fraction(-num, den);
        }
        Fraction operator+ (const Fraction& f) const //重载加号(二元运算符重载)
        {
            return Fraction(num*f.den + den*f.num, den*f.den);
        }
        Fraction operator++ () //重载 前缀“++”
        {
            num += den;
            return *this;
        }
        Fraction operator++ (int)//重载 后缀++,int是一个虚拟参数
        {
            Fraction f(*this);
            num+= den;
            return f;
        }
 
        //重载类型转换符
        //1.必须重载为成员函数
        //2.不需要返回类型,因为运算符本身就是返回的类型
        operator long() const
        {
            return num/den;
        }
 
        //重载赋值运算符“=”,只能重载为成员函数。
        //若不写,系统提供默认赋值(按位赋值)
        //注意:返回类的引用
        //一般顺序:1.判断是否是同一对象
        //          2.若被赋值的对象占用了动态空间,应先释放。再申请空间赋值
        //          3.返回 return *this;
        /*
            String& operator= (const String& s)
            {
                if(&s == this) return *this;
                if(pChar) delete[] pChar;
                if(s.pChar == NULL) p = NULL;
                else
                {
                    pChar = new char[strlen(s.pChar)+1];
                    strcpy(pChar, s.pChar);
                }
                return *this;
            }
        */
        Fraction& operator= (const Fraction& f)//只能重载为成员函数。
        {
            if(&f == this) return *this;
            num = f.num;
            den = f.den;
            return *this;
        }
 
        Fraction& operator+= (const Fraction& f)
        {
            *this = *this + f;
            return *this;
        }
 
        bool operator> (const Fraction& f)const
        {
            return num*f.den > den*f.num;
        }
 
 
    protected:
        void standardize();//标准化
        /*
        标准分数:1. 分母永远为正,分数的符号由分子表示
                  2. 分子分母互为质数,即最简分数
        */
 
    private:
        long num;//分子
        long den;//分母
 
};
 
#endif // FRACTION_H

  

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
//fraction.cpp
#include "fraction.h"
#include <cmath>
 
std::ostream& operator<< (std::ostream& out, const Fraction& f)
{
    if(f.num == 0)
        out << "0";
    else if(1 == f.den) out << f.num;
    else
        out << f.num << "/" << f.den;
    return out;
}
 
static long gcd(long m, long n)
{//求最大公约数
    int r = 0;
    while(n)
    {
        r = m % n;
        m = n;
        n = r;
    }
    return fabs(m);
}
void Fraction::standardize()
{
    if(0L == num || 0L == den)
    {
        num = 0L;
        den = 1L;
        return;
    }
    if(den < 0L)
    {//分数的符号让分子表示
        num = -num;
        den = -den;
    }
    long g = gcd(num,den);
    num /= g;
    den /= g;
}
 
Fraction::Fraction(long n, long d):num(n),den(d)
{
    standardize();
}
 
Fraction::~Fraction()
{
    //dtor
}

  

posted @   htj10  阅读(546)  评论(0编辑  收藏  举报
编辑推荐:
· Linux系列:如何调试 malloc 的底层源码
· AI与.NET技术实操系列:基于图像分类模型对图像进行分类
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语,封装的思维:从隐藏、稳定开始理解其本质意义
阅读排行:
· Apifox不支持离线,Apipost可以!
· 零经验选手,Compose 一天开发一款小游戏!
· Trae 开发工具与使用技巧
· 历时 8 年,我冲上开源榜前 8 了!
· 通过 API 将Deepseek响应流式内容输出到前端
TOP
点击右上角即可分享
微信分享提示