AI 助理
备案控制台
开发者社区 人工智能 文章 正文

《C++语言基础》实践参考——分数类中的运算符重载

2015-04-21 1027
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 返回：贺老师课程教学链接【项目3-分数类中的运算符重载】　　（1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。可以在第4周分数类代码的基础上开始工作。class CFraction{private: int nume; // 分子 int deno; // 分母public: //构造函数及运算符重载

返回：贺老师课程教学链接


【项目3-分数类中的运算符重载】
　　（1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。可以在第4周分数类代码的基础上开始工作。 
class CFraction
{
private:
    int nume;  // 分子
    int deno;  // 分母
public:
    //构造函数及运算符重载的函数声明
};
//重载函数的实现及用于测试的main()函数
[参考解答] 
#include <iostream>
#include <Cmath>
using namespace std;
class CFraction
{
private:
    int nume;  // 分子
    int deno;  // 分母
public:
    CFraction(int nu=0,int de=1):nume(nu),deno(de) {}
    void simplify();
    void display();
    CFraction operator+(const CFraction &c);  //两个分数相加，结果要化简
    CFraction operator-(const CFraction &c);  //两个分数相减，结果要化简
    CFraction operator*(const CFraction &c);  //两个分数相乘，结果要化简
    CFraction operator/(const CFraction &c);  //两个分数相除，结果要化简
    bool operator>(const CFraction &c);
    bool operator<(const CFraction &c);
    bool operator==(const CFraction &c);
    bool operator!=(const CFraction &c);
    bool operator>=(const CFraction &c);
    bool operator<=(const CFraction &c);
};

// 分数化简
void CFraction::simplify()
{
    int m,n,r;
    m=fabs(deno);             //此处存在bug，请参看评论1楼
    n=fabs(nume);
    while(r=m%n)  // 求m，n的最大公约数
    {
        m=n;
        n=r;
    }
    deno/=n;     // 化简
    nume/=n;
    if (deno<0)  // 将分母转化为正数
    {
        deno=-deno;
        nume=-nume;
    }
}

//显示分数
void CFraction::display()
{
    cout<<"("<<nume<<"/"<<deno<<")"<<endl;
}

// 分数相加
CFraction CFraction::operator+(const CFraction &c)
{
    CFraction t;
    t.nume=nume*c.deno+c.nume*deno;
    t.deno=deno*c.deno;
    t.simplify();
    return t;
}

// 分数相减
CFraction CFraction:: operator-(const CFraction &c)
{
    CFraction t;
    t.nume=nume*c.deno-c.nume*deno;
    t.deno=deno*c.deno;
    t.simplify();
    return t;
}

// 分数相乘
CFraction CFraction:: operator*(const CFraction &c)
{
    CFraction t;
    t.nume=nume*c.nume;
    t.deno=deno*c.deno;
    t.simplify();
    return t;
}

// 分数相除
CFraction CFraction:: operator/(const CFraction &c)
{
    CFraction t;
    if (!c.nume) return *this;   //除法无效时，这种情况需要考虑，但这种处理仍不算合理
    t.nume=nume*c.deno;
    t.deno=deno*c.nume;
    t.simplify();
    return t;
}

// 分数比较大小
bool CFraction::operator>(const CFraction &c)
{
    int this_nume,c_nume,common_deno;
    this_nume=nume*c.deno;        // 计算分数通分后的分子，同分母为deno*c.deno
    c_nume=c.nume*deno;
    common_deno=deno*c.deno;
    //if (this_nume>c_nume) return true; 无法应对common_deno<0的情形
    //下面的语句更简练的一种写法if ((this_nume-c_nume)*common_deno>0) return true;
    if ((this_nume>c_nume&&common_deno>0)||(this_nume<c_nume&&common_deno<0)) return true; // 将通分后的分子比较大小
    return false;
}

// 分数比较大小
bool CFraction::operator<(const CFraction &c)
{
    int this_nume,c_nume,common_deno;
    this_nume=nume*c.deno;
    c_nume=c.nume*deno;
    common_deno=deno*c.deno;
    if ((this_nume-c_nume)*common_deno<0) return true;
    return false;
}

// 分数比较大小
bool CFraction::operator==(const CFraction &c)
{
    if (*this!=c) return false;
    return true;
}

// 分数比较大小
bool CFraction::operator!=(const CFraction &c)
{
    if (*this>c || *this<c) return true;
    return false;
}

// 分数比较大小
bool CFraction::operator>=(const CFraction &c)
{
    if (*this<c) return false;
    return true;
}

// 分数比较大小
bool CFraction::operator<=(const CFraction &c)
{
    if (*this>c) return false;
    return true;
}

int main()
{
    CFraction x(1,3),y(-5,10),s;
    cout<<"分数x=1/3      y=-5/10"<<endl;
    s=x+y;
    cout<<"x+y=";
    s.display();
    s=x-y;
    cout<<"x-y=";
    s.display();
    s=x*y;
    cout<<"x*y=";
    s.display();
    s=x/y;
    cout<<"x/y=";
    s.display();

    x.display();
    if (x>y) cout<<"大于"<<endl;
    if (x<y) cout<<"小于"<<endl;
    if (x==y) cout<<"等于"<<endl;
    y.display();
    cout<<endl;
    return 0;
}


　　（2）在（1）的基础上，实现分数类中的对象和整型数的四则运算。分数类中的对象可以和整型数进行四则运算，且运算符合交换律。例如：CFraction a(1,3),b; int i=2; 可以完成b=a+i;。同样，可以完成i+a, 45+a, a*27, 5/a等各种运算。

[参考解答]

#include <iostream>
using namespace std;
class CFraction
{
private:
    int nume;  // 分子
    int deno;  // 分母
public:
    CFraction(int nu=0,int de=1):nume(nu),deno(de) {}
    void simplify();
    void display();

    friend CFraction operator+(const CFraction &c1, const CFraction &c2);  //两个分数相加，结果要化简
    friend CFraction operator-(const CFraction &c1, const CFraction &c2);  //两个分数相减，结果要化简
    friend CFraction operator*(const CFraction &c1, const CFraction &c2);  //两个分数相乘，结果要化简
    friend CFraction operator/(const CFraction &c1, const CFraction &c2);  //两个分数相除，结果要化简

    friend CFraction operator+(const CFraction &c, int i);
    friend CFraction operator+(int i, const CFraction &c );
    friend CFraction operator-(const CFraction &c, int i);
    friend CFraction operator-(int i, const CFraction &c );
    friend CFraction operator*(const CFraction &c, int i);
    friend CFraction operator*(int i, const CFraction &c );
    friend CFraction operator/(const CFraction &c, int i);
    friend CFraction operator/(int i, const CFraction &c );

    CFraction operator+();  //取正一目运算
    CFraction operator-();  //取反一目运算

    friend bool operator>(const CFraction &c1, const CFraction &c2);
    friend bool operator<(const CFraction &c1, const CFraction &c2);
    friend bool operator==(const CFraction &c1, const CFraction &c2);
    friend bool operator!=(const CFraction &c1, const CFraction &c2);
    friend bool operator>=(const CFraction &c1, const CFraction &c2);
    friend bool operator<=(const CFraction &c1, const CFraction &c2);

    friend bool operator>(const CFraction &c, int i);
    friend bool operator>(int i, const CFraction &c);
    friend bool operator<(const CFraction &c, int i);
    friend bool operator<(int i, const CFraction &c);
    friend bool operator==(const CFraction &c, int i);
    friend bool operator==(int i, const CFraction &c);
    friend bool operator!=(const CFraction &c, int i);
    friend bool operator!=(int i, const CFraction &c);
    friend bool operator>=(const CFraction &c, int i);
    friend bool operator>=(int i, const CFraction &c);
    friend bool operator<=(const CFraction &c, int i);
    friend bool operator<=(int i, const CFraction &c);

};

// 分数化简
void CFraction::simplify()
{
    int m,n,r;
    m=abs(deno);
    n=abs(nume);
    while(r=m%n)  // 求m，n的最大公约数
    {
        m=n;
        n=r;
    }
    deno/=n;     // 化简
    nume/=n;
    if (deno<0)  // 将分母转化为正数
    {
        deno=-deno;
        nume=-nume;
    }
}

//显示分数
void CFraction::display()
{
    cout<<"("<<nume<<"/"<<deno<<")"<<endl;
}

// 分数相加
CFraction operator+(const CFraction &c1, const CFraction &c2)
{
    CFraction t;
    t.nume=c1.nume*c2.deno+c2.nume*c1.deno;
    t.deno=c1.deno*c2.deno;
    t.simplify();
    return t;
}

// 分数相减
CFraction operator-(const CFraction &c1, const CFraction &c2)
{
    CFraction t;
    t.nume=c1.nume*c2.deno-c2.nume*c1.deno;
    t.deno=c1.deno*c2.deno;
    t.simplify();
    return t;
}

// 分数相乘
CFraction operator*(const CFraction &c1, const CFraction &c2)
{
    CFraction t;
    t.nume=c1.nume*c2.nume;
    t.deno=c1.deno*c2.deno;
    t.simplify();
    return t;
}

// 分数相除
CFraction operator/(const CFraction &c1, const CFraction &c2)
{
    CFraction t;
    if (!c2.nume) return c1;
    t.nume=c1.nume*c2.deno;
    t.deno=c1.deno*c2.nume;
    t.simplify();
    return t;
}

CFraction operator+(const CFraction &c, int i)
{
    CFraction c1(c.nume+i*c.deno,c.deno);
    c1.simplify();
    return c1;
}

CFraction operator+(int i, const CFraction &c )
{
    CFraction c1(c.nume+i*c.deno,c.deno);
    c1.simplify();
    return c1;
}

CFraction operator-(const CFraction &c, int i)
{
    CFraction c1(c.nume-i*c.deno,c.deno);
    c1.simplify();
    return c1;
}

CFraction operator-(int i, const CFraction &c )
{
    CFraction c1(i*c.deno-c.nume,c.deno);
    c1.simplify();
    return c1;
}
CFraction operator*(const CFraction &c, int i)
{
    CFraction c1(c.nume*i,c.deno);
    c1.simplify();
    return c1;
}

CFraction operator*(int i, const CFraction &c )
{
    CFraction c1(c.nume*i,c.deno);
    c1.simplify();
    return c1;
}

CFraction operator/(const CFraction &c, int i)
{
    CFraction c1(c.nume,c.deno*i);
    c1.simplify();
    return c1;
}

CFraction operator/(int i, const CFraction &c )
{
    CFraction c1(i*c.deno,c.nume);
    c1.simplify();
    return c1;
}

// 分数取正号
CFraction CFraction:: operator+()
{
    return *this;
}

// 分数取负号
CFraction CFraction:: operator-()
{
    CFraction c;
    c.nume=-nume;
    c.deno=-deno;
    return c;
}

// 分数比较大小
bool operator>(const CFraction &c1, const CFraction &c2)
{
    int c1_nume,c2_nume,common_deno;
    c1_nume=c1.nume*c2.deno;        // 计算分数通分后的分子，同分母为c1.deno*c2.deno
    c2_nume=c2.nume*c1.deno;
    common_deno=c1.deno*c2.deno;
    //if (c1_nume>c2_nume) return true; 无法应对common_deno<0的情形
    //下面的语句更简练的一种写法if ((c1_nume-c2_nume)*common_deno>0) return true;
    if (c1_nume>c2_nume&&common_deno>0||c1_nume<c2_nume&&common_deno<0) return true; // 将通分后的分子比较大小
    return false;
}

// 分数比较大小
bool operator<(const CFraction &c1, const CFraction &c2)
{
    int c1_nume,c2_nume,common_deno;
    c1_nume=c1.nume*c2.deno;
    c2_nume=c2.nume*c1.deno;
    common_deno=c1.deno*c2.deno;
    if ((c1_nume-c2_nume)*common_deno<0) return true;
    return false;
}

// 分数比较大小
bool operator==(const CFraction &c1, const CFraction &c2)
{
    if (c1!=c2) return false;
    return true;
}

// 分数比较大小
bool operator!=(const CFraction &c1, const CFraction &c2)
{
    if (c1>c2 || c1<c2) return true;
    return false;
}

// 分数比较大小
bool operator>=(const CFraction &c1, const CFraction &c2)
{
    if (c1<c2) return false;
    return true;
}

// 分数比较大小
bool operator<=(const CFraction &c1, const CFraction &c2)
{
    if (c1>c2) return false;
    return true;
}


bool operator>(const CFraction &c, int i)
{
    if(c.deno>0)
        return c.nume>(i*c.deno);
    else
        return c.nume<(i*c.deno);
}

bool operator>(int i, const CFraction &c)
{
    if(c.deno>0)
        return (i*c.deno)>c.nume;
    else
        return (i*c.deno)<c.nume;
}

bool operator<(const CFraction &c, int i)
{
    if(c.deno>0)
        return c.nume<(i*c.deno);
    else
        return c.nume>(i*c.deno);
}
bool operator<(int i, const CFraction &c)
{
    if(c.deno>0)
        return (i*c.deno)<c.nume;
    else
        return (i*c.deno)>c.nume;
}

bool operator==(const CFraction &c, int i)
{
    return c.nume==(i*c.deno);
}
bool operator==(int i, const CFraction &c)
{
    return c.nume==(i*c.deno);
}
bool operator!=(const CFraction &c, int i)
{
    return c.nume!=(i*c.deno);
}
bool operator!=(int i, const CFraction &c)
{
    return c.nume!=(i*c.deno);
}
bool operator>=(const CFraction &c, int i)
{
    return !(c<i);
}
bool operator>=(int i, const CFraction &c)
{
    return !(i<c);
}

bool operator<=(const CFraction &c, int i)
{
    return !(c>i);
}
bool operator<=(int i, const CFraction &c)
{
    return !(i>c);
}

int main()
{
    CFraction x(1,3),y(-5,10),s;
    cout<<"分数x=1/3      y=-5/10"<<endl;
    s=+x+y;
    cout<<"+x+y=";
    s.display();
    s=x-y;
    cout<<"x-y=";
    s.display();
    s=x*y;
    cout<<"x*y=";
    s.display();
    s=x/y;
    cout<<"x/y=";
    s.display();
    s=-x+y;
    cout<<"-x+y=";
    s.display();

    x.display();
    if (x>y) cout<<"大于"<<endl;
    if (x<y) cout<<"小于"<<endl;
    if (x==y) cout<<"等于"<<endl;
    y.display();
    cout<<endl;

    CFraction c1(5,3),c2;
    //以下建议在调试环境中完成测试，
    c2=c1+5;
    c2=5+c1;

    c2=c1-5;
    c2=5-c1;

    c2=c1*5;
    c2=5*c1;

    c2=c1/5;
    c2=5/c1;

    bool b;

    b=(c1>2);
    b=(2>c1);


    return 0;
}


文章标签：
C++
机器学习/深度学习
关键词：
C++类
C++实践
C++运算符重载
C++类运算符重载
C++语言基础
贺利坚
目录
相关文章
RossyYan
|
2月前
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
本关任务：编写一个程序实现顺序栈的基本运算。开始你的任务吧，祝你成功！​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念：初始化栈是为栈的使用做准备，包括分配内存空间（如果是动态分配）和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈，通常需要定义一个数组来存储栈元素，并设置一个变量来记录栈顶位置；对于链式栈，需要定义节点结构，包含数据域和指针域，同时初始化栈顶指针。 示例（顺序栈）： 以下是一个简单的顺序栈初始化示例，假设用C语言实现，栈中存储
RossyYan
160 77
RossyYan
|
2月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
81 19
RossyYan
|
2月前
|
C++
【C++数据结构——树】二叉树的性质（头歌实践教学平台习题）【合集】
本文档介绍了如何根据二叉树的括号表示串创建二叉树，并计算其结点个数、叶子结点个数、某结点的层次和二叉树的宽度。主要内容包括： 1. **定义二叉树节点结构体**：定义了包含节点值、左子节点指针和右子节点指针的结构体。 2. **实现构建二叉树的函数**：通过解析括号表示串，递归地构建二叉树的各个节点及其子树。 3. **使用示例**：展示了如何调用 `buildTree` 函数构建二叉树并进行简单验证。 4. **计算二叉树属性**： - 计算二叉树节点个数。 - 计算二叉树叶子节点个数。 - 计算某节点的层次。 - 计算二叉树的宽度。 最后，提供了测试说明及通关代
RossyYan
60 10
RossyYan
|
2月前
|
存储 C++
【C++数据结构——树】哈夫曼树（头歌实践教学平台习题） 【合集】
【数据结构——树】哈夫曼树（头歌实践教学平台习题）【合集】目录 任务描述 相关知识 测试说明 我的通关代码： 测试结果：任务描述 本关任务：编写一个程序构建哈夫曼树和生成哈夫曼编码。 相关知识 为了完成本关任务，你需要掌握： 1.如何构建哈夫曼树， 2.如何生成哈夫曼编码。 测试说明 平台会对你编写的代码进行测试： 测试输入： 1192677541518462450242195190181174157138124123 (用户分别输入所列单词的频度） 预
RossyYan
72 14
【C++数据结构——树】哈夫曼树（头歌实践教学平台习题） 【合集】
RossyYan
|
2月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类（头歌实践教学平台习题）【合集】
声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，以及两个公有成员函数run、stop。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中，类是创建对象的蓝图。类的声明定义了类的成员，包括数据成员（变量）和成员函数（方法）。一个简单的类声明示例如下： classMyClass{ public: int
RossyYan
68 13
RossyYan
|
2月前
|
Java C++
【C++数据结构——树】二叉树的基本运算（头歌实践教学平台习题）【合集】
本关任务：编写一个程序实现二叉树的基本运算。​ 相关知识 创建二叉树 销毁二叉树 查找结点 求二叉树的高度 输出二叉树 //二叉树节点结构体定义 structTreeNode{ intval; TreeNode*left; TreeNode*right; TreeNode(intx):val(x),left(NULL),right(NULL){} }; 创建二叉树 //创建二叉树函数（简单示例，手动构建） TreeNode*create
RossyYan
61 12
RossyYan
|
2月前
|
算法 C++
【C++数据结构——图】最小生成树（头歌实践教学平台习题） 【合集】
【数据结构——图】最小生成树（头歌实践教学平台习题）目录 任务描述 相关知识 测试说明 我的通关代码: 测试结果：【合集】任务描述 本关任务：编写一个程序求图的最小生成树。相关知识 为了完成本关任务，你需要掌握：1.建立邻接矩阵，2.Prim算法。建立邻接矩阵 上述带权无向图对应的二维数组，根据它建立邻接矩阵，如图1建立下列邻接矩阵。注意：INF表示无穷大，表示整数：32767 intA[MAXV][MAXV];Prim算法 普里姆(Prim)算法是一种构造性算法，从候选边中挑
RossyYan
48 10
RossyYan
|
2月前
|
存储 算法 C++
【C++数据结构——图】图的邻接矩阵和邻接表的存储（头歌实践教学平台习题）【合集】
本任务要求编写程序实现图的邻接矩阵和邻接表的存储。需掌握带权有向图、图的邻接矩阵及邻接表的概念。邻接矩阵用于表示顶点间的连接关系，邻接表则通过链表结构存储图信息。测试输入为图的顶点数、边数及邻接矩阵，预期输出为Prim算法求解结果。通关代码提供了完整的C++实现，包括输入、构建和打印邻接矩阵与邻接表的功能。
RossyYan
59 10
RossyYan
|
2月前
|
C++
【C++数据结构——栈和队列】括号配对（头歌实践教学平台习题）【合集】
【数据结构——栈和队列】括号配对（头歌实践教学平台习题）【合集】（1）遇到左括号：进栈Push()（2）遇到右括号：若栈顶元素为左括号，则出栈Pop()；否则返回false。（3）当遍历表达式结束，且栈为空时，则返回true，否则返回false。本关任务：编写一个程序利用栈判断左、右圆括号是否配对。为了完成本关任务，你需要掌握：栈对括号的处理。（1）遇到左括号：进栈Push()开始你的任务吧，祝你成功！测试输入：(()))
RossyYan
48 7
RossyYan
|
2月前
|
存储 C++ 索引
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】
【数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】初始化队列、销毁队列、判断队列是否为空、进队列、出队列等。本关任务：编写一个程序实现环形队列的基本运算。(6)出队列序列:yzopq2*(5)依次进队列元素:opq2*(6)出队列序列:bcdef。(2)依次进队列元素:abc。(5)依次进队列元素:def。(2)依次进队列元素:xyz。开始你的任务吧，祝你成功！(4)出队一个元素a。(4)出队一个元素x。
RossyYan
53 13
【C++数据结构——栈与队列】环形队列的基本运算（头歌实践教学平台习题）【合集】

热门文章

最新文章

  • 1
    彻底摘明白 C++ 的动态内存分配原理
  • 2
    类和对象的简述（c++篇）
  • 3
    【C++篇】深度解析类与对象（上）
  • 4
    c++ linux通过实现独立进程之间的通信和传递字符串 demo
  • 5
    【c++丨STL】priority_queue（优先级队列）的使用与模拟实现
  • 6
    模拟实现c++中的vector模版
  • 7
    从集思录可转债数据探秘：Python与C++实现的移动平均算法应用
  • 8
    员工屏幕监控系统之 C++ 图像差分算法
  • 9
    模拟实现c++中的list模版
  • 10
    【C++篇】深度解析类与对象（下）
  • 1
    公司局域网管理中的哈希表查找优化 C++ 算法探究
    19
  • 2
    【c++】继承（继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员）
    29
  • 3
    基于 C++ 语言的迪杰斯特拉算法在局域网计算机管理中的应用剖析
    35
  • 4
    C++入门基础
    15
  • 5
    【c++】模板详解(2)
    28
  • 6
    公司监控上网软件架构：基于 C++ 链表算法的数据关联机制探讨
    19
  • 7
    【c++丨STL】priority_queue（优先级队列）的使用与模拟实现
    52
  • 8
    C++ noexcept 关键字的关键作用
    27
  • 9
    彻底摘明白 C++ 的动态内存分配原理
    102
  • 10
    C++ 容器全面剖析：掌握 STL 的奥秘，从入门到高效编程
    23

    • 相关课程

    更多
  • C++ 入门教程开发文档
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Python语言基础 - 函数、面向对象、异常处理
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • C语言学习教程

    • 相关电子书

    更多
  • 继承与功能组合
  • 对象的生命期管理
  • 移动与复制
    • 下一篇
    阿里云负载均衡SLB版本CLB、ALB和NLB有什么区别如何选择？