fraction类的运算重载

重载>> 和 <<

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

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

运算符重载举例

//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

//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
}