类相关的编程（1）——分数类

最新推荐文章于 2023-10-15 18:01:51 发布

sjtuSecondSilly

最新推荐文章于 2023-10-15 18:01:51 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

分类专栏： C++语法与算法文章标签： c++ 算法开发语言

本文链接：https://blog.youkuaiyun.com/White__River/article/details/123462840

C++语法与算法专栏收录该内容

17 篇文章

订阅专栏

本文介绍了如何在C++中创建一个分数类(Fraction)，包括设置和获取分子分母的方法，以及内联函数的使用。通过`normalize`函数确保分数标准化，并实现了分数的加法和乘法操作，涉及通分和最小公倍数的概念。代码示例展示了类的完整实现和测试用例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义分数(Fraction)类

参考《轻松学会C++》第三版

“理解面向对象变成的好方法是着手定义一个新的数据类型”

简单地稍微定义一个分数类

class Fraction{
private:
    int num;
    int den;
public:
    void set(int numerator, int denominator);
    int get_num();
    int get_den();
    
    
private:
    void normalize();
    int gcf(int a, int b);//great common factor
    int lcm(int a, int b);//least common multiple

};


void Fraction::set(int numerator, int denominator){
    num = numerator;
    den = denominator;
}

int Fraction::get_num(){
    return num;
}

int Fraction::get_den(){
    return den;
}

其他的先搁置

内联函数（inline function）

类似像这种起“设置”、“获取值”之类的超级简单的函数，可以用"内联函数"来写
通常函数调用时，程序会讲控制权转移给相应的代码块，但是，对于这种函数体很短的函数，这样做往往效率不足
内联函数执行时，程序不会将控制转移到单独的代码块，相反，编译器会直接将函数调用编译成函数主体

内联函数的缺点是减少可读性且不符合结构化编程的原则，不过对于这种超级短的函数，这些缺点可以忽略不计
反而，内联函数节省空间提高效率的优点大大地凸显了出来‘
这是一个trade-off，通常情况下不鼓励使用内联函数，但凡事都有例外。

因此我们可以直接在类里面写
void set(){num = numerator;den = denominator;}

一旦程序遇到Fraction frac.set(1,2);
会自动替换成
{Fraction frac.num = 1;Fraction frac.den = 2;}

以下为代码

class Fraction{
private:
    int num;
    int den;
public:
    void set(int numerator, int denominator)
    {
        num = numerator;
        den = denominator;
        normalize();
    }
    int get_num(){return num;}
    int get_den(){return den;}
    
    
private:
    void normalize();
    int gcf(int a, int b);//great common factor
    int lcm(int a, int b);//least common multiple

};

//normalize函数的重要性在于：它确保相等的值采取一致的表示方式
void Fraction::normalize(){
    if(den == 0|| num = 0)
    {
        num = 0;
        den = 1;
    }
    //标准化，将分数的正负性统一体现在分子，分子正则分数正
    if(den < 0)
    {
        num = num*(-1);
        den = den*(-1);
    }
    
    int common_factor = gcf(num,den);
    num = num/n;
    den = den/n;
}

//递归调用自身时，不必多此一举写解析算符::
//因为在类成员函数内部，默认使用该类的作用域
int Fraction::gcf(int a, int b)
{
    if(b==0)
        return abs(a);
    else
        return gcf(b,a%b);
}


int Fraction::lcm(int a, int b)
{
    int n;
    n = gcf(a,b);
    return a*b/n;
}

测试代码

int main()
{
    int a = 5;
    int b = 10;

    Fraction fraction1;
    fraction1.set(a,b);

    cout<<fraction1.get_num()<<endl;
    cout<<fraction1.get_den()<<endl;
    return 0;
}

在类中引入分数加减法

分数能够相加减，关键在于通分
通分的关键，在于找到两个分数的分母的最小公倍数
可以将这一最小公倍数称为最小公分母(Lowest Common Denominator)

//
lcd = lcm(den1,den2);

以下为最终改进版代码

#include <cmath>
#include <iostream>

using namespace std;
class Fraction{
private:
    int num;
    int den;
public:
    void set(int numerator, int denominator)
    {
        num = numerator;
        den = denominator;
        normalize();
    }
    int get_num(){return num;}
    int get_den(){return den;}
    Fraction add(Fraction other_frac);
    Fraction multi(Fraction other_frac);


private:
    void normalize();
    int gcf(int a, int b);//great common factor
    int lcm(int a, int b);//least common multiple

};

//normalize函数的重要性在于：它确保相等的值采取一致的表示方式
void Fraction::normalize(){
    if(den == 0|| num == 0)
    {
        num = 0;
        den = 1;
    }
    //标准化，将分数的正负性统一体现在分子，分子正则分数正
    if(den < 0)
    {
        num = num*(-1);
        den = den*(-1);
    }

    int common_factor = gcf(num,den);
    num = num/common_factor;
    den = den/common_factor;
}

//递归调用自身时，不必多此一举写解析算符::
//因为在类成员函数内部，默认使用该类的作用域
int Fraction::gcf(int a, int b)
{
    if(b==0)
        return abs(a);
    else
        return gcf(b,a%b);
}


int Fraction::lcm(int a, int b)
{
    int n;
    n = gcf(a,b);
    return a*b/n;
}



Fraction Fraction::add(Fraction other_frac)
{
    Fraction result_frac;

    int lcd = lcm(den,other_frac.den);
    int num1 = num*lcd/den;
    int num2 = other_frac.num*lcd/other_frac.den;

    int result_num = num1+num2;
    int result_den = lcd;

    result_frac.set(result_num,result_den);
    return result_frac;
}
Fraction Fraction::multi(Fraction other_frac)
{
    Fraction result_frac;

    int result_num = num*other_frac.num;
    int result_den = den*other_frac.den;


    result_frac.set(result_num,result_den);
    return result_frac;
}

int main()
{
    int a = 5;
    int b = 10;

    Fraction fraction1;
    fraction1.set(a,b);

    int num2 = 3;
    int den2 = 10;

    Fraction fraction2;
    fraction2.set(num2,den2);

//    Fraction result_frac;
//    result_frac = fraction2.add(fraction1);
//
//    cout<<result_frac.get_num()<<"  "<<result_frac.get_den()<<endl;
    Fraction result_frac;
    result_frac = fraction2.multi(fraction1);

    cout<<result_frac.get_num()<<"  "<<result_frac.get_den()<<endl;
    return 0;
}