c++ Fraction类操作符重载练习

#include <iostream>

using namespace std;
int GreatestCommonDivisor(int m,int n) //辗转相除法求最大公约数

{

    int r;

    do

    {

        r = m % n;

        m = n;

        n = r;

    } while ( r != 0 );

    return m;

}
class Fraction;                                            //

ostream& operator<<(ostream& out,const Fraction &fra);    //

istream& operator>>(istream& in,const Fraction& fra);    //此三行为满足vc6.0的编译逻辑而声明
class Fraction{

private:

    int fenzi,fenmu;                            //分子，分母

public:

    Fraction(){}

    ~Fraction(){}

    Fraction(int fenzi,int fenmu);

    Fraction operator+(const Fraction &fra)const;

    Fraction operator-(const Fraction &fra)const;

    Fraction operator*(const Fraction &fra)const;

    Fraction operator/(const Fraction &fra)const;

    friend ostream& operator<<(ostream& out,const Fraction& fra);//i/o重载必须使用友元重载

    friend istream& operator>>(istream& in,const Fraction& fra);

    void setValue(int mu,int zi);

};

Fraction::Fraction(int zi,int mu):fenzi(zi),fenmu(mu){

    if(mu==0){

        cout<<"分母不能为0!"<<endl;

        exit(0);

    }

}

ostream& operator<<(ostream& out,const Fraction &fra){

    if(fra.fenmu<0)

        out<<"(-"<<fra.fenzi<<"/"<<-fra.fenmu<<")";        //负分数显示

    else if(fra.fenzi<0)

        out<<"(-"<<-fra.fenzi<<"/"<<fra.fenmu<<")";

    else if(fra.fenmu==1)

        out<<fra.fenzi;                                    //整数显示

    else

        out<<fra.fenzi<<"/"<<fra.fenmu;                    //正分数显示

    return out;

}
istream& operator>>(istream& in, Fraction& fra){

    int mu,zi;

    cout<<"请输入分母与分子"<<endl;

    in>>mu>>zi;

    fra.setValue(mu,zi);

    return in;

}

void Fraction::setValue(int mu,int zi){

    fenmu=mu;

    fenzi=zi;

}

Fraction Fraction::operator+(const Fraction &fra)const{

    int a=fenzi,b=fenmu;    //▲▲▲重点▲▲▲

    //一定要使用const，因为不用的话会使上次运算的数据赋值到下次的运算l-value中

    //因为const函数无法改变类的内部变量，所以要用替身，若此处重载改用friend重载

    //则可以有效地避免此问题，因为friend重载的操作符有两个引用的参数

    a=fra.fenmu*fenzi+fra.fenzi*fenmu;

    b*=fra.fenmu;

    int g=GreatestCommonDivisor(a,b);

    if (g!=1)

    {

        a/=g;

        b/=g;

    }

    return Fraction(a,b);

}

Fraction Fraction::operator-(const Fraction &fra)const{

    int a=fenzi,b=fenmu;

    a=fra.fenmu*fenzi-fra.fenzi*fenmu;

    b*=fra.fenmu;

    int g=GreatestCommonDivisor(a,b);

    if (g!=1)

    {

        a/=g;

        b/=g;

    }

    return Fraction(a,b);

}

Fraction Fraction::operator*(const Fraction &fra)const{

    int a=fenzi,b=fenmu;

    a*=fra.fenzi;

    b*=fra.fenmu;

    int g=GreatestCommonDivisor(a,b);

    if (g!=1)

    {

        a/=g;

        b/=g;

    }

    return Fraction(a,b);

}

Fraction Fraction::operator/(const Fraction &fra)const{

    return *this*Fraction(fra.fenmu,fra.fenzi);

}

void main()

{

    Fraction a(1,2);

    Fraction b(1,4);

    Fraction c=a+b;

    Fraction d=a-b;

    Fraction e=b-a;

    Fraction f=a*b;

    Fraction g=a/b;

    cout<<"a=1/2"<<endl

        <<"b=1/4"<<endl

        <<"a+b="<<c<<endl

        <<"a-b="<<d<<endl

        <<"b-a="<<e<<endl

        <<"a*b="<<f<<endl

        <<"a/b="<<g<<endl;

    Fraction h;

    cin>>h;

    cout<<h<<endl;

}

时间： 2024-08-11 10:54:56

c++ Fraction类操作符重载练习的相关文章

第二十篇：类操作符重载的相关规定与具体实现示例

前言有书这么说过,C++设计的最大目的在于允许程序员定义自己的类型,并使它们用起来跟内置类型一样容易和直观.就目前看来,要实现这一点,最核心的莫过于操作符的重载.科学的重载可以让类的使用最大程度地接近内置类型.本文将讨论类操作符重载涉及到的一些原则和具体做法. 实现类操作符重载的两种思路 1. 友元函数法: 将待重载操作符视作非成员函数( 它声明为操作数类型的友元函数 ) 应当采用这种机制重载的运算符有:IO操作符,算数操作符,关系操作符. 2. 成员函数法: 将待重载操作符视作特殊的成员函数

4 C++基础4 类 const函数转全局函数返回*this 数组类。友元函数类操作符重载

1,请问类中函数 const修饰的谁? [email protected]:~/c++$ cat main.cpp #include <iostream> #include <stdlib.h> using namespace std; class A { public: //const的三种写法 //const void fun(int a,int b) //void const fun(int a,int b) //void fun(int a,int b) const vo

Kotlin操作符重载：把标准操作加入到任何类中（KAD 17）

作者:Antonio Leiva 时间:Mar 21, 2017 原文链接:https://antonioleiva.com/operator-overload-kotlin/ 就像其他每种语言一样,在Kotlin中,已经预定义了一些操作符执行一定的操作. 最典型的是加(+),减(-),乘(*),除(/),而且还有很多. 类似Java这样的一些语言,这些操作符被限制在一些特定的数量类型上,且没有方法让其他类型数据使用这些操作符. 还有在像Scala这样的其他语言中,由于函数名称可接受任何符号,我

在c++ 模板类外写操作符重载函数，并且是模板类的友元函数

看视频教程说不能在c++ 模板类外写操作符重载函数,并且是模板类的友元函数我试了试,可以,放出测试代码: #include <iostream> using namespace std; template<typename T> class A { public: A(T a) { this->a = a; } template<typename T> //加上这句就可以了 friend A<T> operator+(A<T> &

【C/C++学院】（8）全局函数和类成员函数转化/友元/操作符重载

1.全局函数和类成员函数转化全局函数和成员函数的相互转化:只需要修改一个指向本类的this指针: #include <iostream> using namespace std; class Test { public: Test(int a, int b) { this->a = a; this->b = b; } //成员函数 Test &Gadd2(Test &t2) { this->a = this->a + t2.a; this->b

C++ Primer 学习笔记_27_操作符重载与转换（2）--++/--运算符重载、！运算符重载、赋值运算符重载、String类（[]、 +、 += 运算符重载）、>>和<<运算符重载

C++ Primer 学习笔记_27_操作符重载与转换(2)--++/--运算符重载.!运算符重载.赋值运算符重载 .String类([]. +. += 运算符重载).>>和<<运算符重载一.++/--运算符重载 1.前置++运算符重载成员函数的方式重载,原型为: 函数类型 & operator++(); 友元函数的方式重载,原型为: friend 函数类型 & operator++(类类型 &); 2.后置++运算符重载成员函数的方式重载,原型为:

21.C++- ++操作符重载、隐式转换之explicit关键字、类的类型转换函数

++操作符重载 ++操作符分为前置++和后置++,比如: ++a; a++; ++操作符可以进行全局函数或成员函数重载重载前置++操作符不需要参数重载后置++操作符需要一个int类型的占位参数前置++操作符的返回值为*this 后置++操作符的返回值为临时对象例如: 转换规则如下所示: 比如: 隐式转换的隐患隐式转换有时会因为类型不同,得到的结果大有不同,也是常见bug之一. 参考以下示例: 运行打印: 答案并非是-1000. 同样,我们使用构造函数时,也经常使用隐式转换参考以下示

类和对象（17）—— 操作符重载

1.操作符重载的基本语法所谓重载,就是重新赋予新的含义.函数重载就是对一个已有的函数赋予新的含义,使之实现新功能,因此,一个函数名就可以用来代表不同功能的函数,也就是"一名多用". 运算符也可以重载.实际上,我们已经在不知不觉之中使用了运算符重载.例如,大家都已习惯于用加法运算符"+"对整数.单精度数和双精度数进行加法运算,如5+8,5.8+3.67等,其实计算机对整数.单精度数和双精度数的加法操作过程是很不相同的,但由于C++已经对运算符"+"

C++--操作符重载复数类

一.操作符重载 Q:下面的复数解决方案是否可行? class Complex { public: int a; int b; }; int main() { Complex c1={1,2}; Complex c2={3,4}; Complex c3=c1+c2; return 0; } 该段代码想要实现的是将两个复数类进行相加得出第三个类代码实现的运行结果由上面的结果图可以得知,出现的错误是无法匹配+号操作符的操作,同时出现的潜在问题是a与b是public成员,在实际的操作中应将a与b设置为

c++ Fraction类 操作符重载练习

c++ Fraction类 操作符重载练习的相关文章

c++ Fraction类操作符重载练习

c++ Fraction类操作符重载练习的相关文章