C++怎么使用带有重载的abs函数

你可以使用C语言中的abs函数来计算一个数的绝对值，如果你想使用带有重载的abs函数，你需要使用C++语言。在C++中，abs函数有多个重载版本，可以接受不同类型的参数，例如int、long、float、double等。你可以根据需要选择合适的重载版本来使用。如果你不确定应该使用哪个版本，可以查看C++标准库的文档或者参考相关的教程。

相关问题

用C++写出解决下列问题的代码，设计一个图形基类：Shape，在此基础上派生Rectangle、Circle、Triangle 类。 1、Cirlce 类基本信息：圆心坐标、半径； Rectangle 类基本信息：长、宽； Triangle 类基本信息：三个顶点坐标； 其中：成员变量为 private 属性，成员函数为public 属性； 2、每个图形类有多个构造函数：缺省构造函数、带参数的构造函数； 3、每个图形类有计算图形的面积GetArea()，显示图形的基本信息函数Show()，修改基 本信息的函数Set(形参)。 [实验提示] 1、在派生类的构造函数中，应注意对基类数据成员的初始化； 2、各类图形面积的计算方法不同， 因此不能在基类 Shape 中统一确定计算的方法。在 基类Shape 中实现计算面积功能的函数体GetArea()应为空，在派生类中根据同名覆盖原则 定义各自的同名函数实现具体功能

好的，以下是代码实现：

#include<iostream>
using namespace std;

class Shape{
protected:
    double area;  //面积
public:
    Shape(){ area=0; }
    virtual double GetArea() = 0; //纯虚函数
    virtual void Show() = 0;
    virtual void Set() = 0;
};

class Circle:public Shape{
private:
    double x, y, r; //圆心坐标和半径
public:
    Circle(){ x=0; y=0; r=0; }
    Circle(double x_, double y_, double r_){ x=x_; y=y_; r=r_; }
    double GetArea(){ return 3.14*r*r; }
    void Show(){
        cout<<"圆心坐标为("<<x<<","<<y<<")，半径为"<<r<<endl;
        cout<<"面积为"<<GetArea()<<endl;
    }
    void Set(){
        cout<<"请输入圆心坐标x、y和半径r：";
        cin>>x>>y>>r;
    }
};

class Rectangle:public Shape{
private:
    double length, width; //长和宽
public:
    Rectangle(){ length=0; width=0; }
    Rectangle(double l, double w){ length=l; width=w; }
    double GetArea(){ return length*width; }
    void Show(){
        cout<<"长为"<<length<<"，宽为"<<width<<endl;
        cout<<"面积为"<<GetArea()<<endl;
    }
    void Set(){
        cout<<"请输入长和宽：";
        cin>>length>>width;
    }
};

class Triangle:public Shape{
private:
    double x1, y1, x2, y2, x3, y3; //三个顶点坐标
public:
    Triangle(){ x1=0; y1=0; x2=0; y2=0; x3=0; y3=0; }
    Triangle(double x1_, double y1_, double x2_, double y2_, double x3_, double y3_){
        x1=x1_; y1=y1_; x2=x2_; y2=y2_; x3=x3_; y3=y3_;
    }
    double GetArea(){ return abs(x1*y2+x2*y3+x3*y1-x1*y3-x2*y1-x3*y2)/2; }
    void Show(){
        cout<<"三个顶点坐标为("<<x1<<","<<y1<<")，("<<x2<<","<<y2<<")，("<<x3<<","<<y3<<")"<<endl;
        cout<<"面积为"<<GetArea()<<endl;
    }
    void Set(){
        cout<<"请输入三个顶点坐标：";
        cin>>x1>>y1>>x2>>y2>>x3>>y3;
    }
};

int main(){
    Circle c1(1,2,3);
    c1.Show();
    c1.Set();
    c1.Show();
    
    Rectangle r1(4,5);
    r1.Show();
    r1.Set();
    r1.Show();
    
    Triangle t1(0,0,0,3,4,0);
    t1.Show();
    t1.Set();
    t1.Show();
    
    return 0;
}

在这个代码中，我们首先定义了一个抽象基类 Shape，其中包含了一个纯虚函数 GetArea()，表示求图形面积的方法。接着，我们分别定义了三个派生类 Circle、Rectangle 和 Triangle，分别表示圆、矩形和三角形。这三个类中均包含了成员变量和成员函数，并且都重载了基类中的三个方法：GetArea()、Show() 和 Set()，以实现自己的计算面积、显示基本信息和修改基本信息的功能。

最后，我们在主函数中创建了三个对象：Circle c1、Rectangle r1 和 Triangle t1，分别使用了不同的构造函数初始化它们的成员变量，并分别调用了它们的 Show() 和 Set() 方法，以展示它们的基本信息并修改它们的成员变量。

分别用成员函数和友元函数重载运算符，使对整型的运算符＝、+、、*、/适用于分数运 要求: (1）输出结果是最简分数（可以是带分数）； 2）分母为1，只输出分子。

好的，下面是一个简单的 C++ 程序，其中定义了一个 Fraction 类，重载了运算符 =、+、-、*、/ 等，并且满足上述要求：

#include <iostream>
using namespace std;

class Fraction {
public:
    Fraction(int num = 0, int den = 1) : m_num(num), m_den(den) {}
    Fraction(const Fraction& other) : m_num(other.m_num), m_den(other.m_den) {}

    Fraction& operator=(const Fraction& other);
    friend Fraction operator+(const Fraction& a, const Fraction& b);
    friend Fraction operator-(const Fraction& a, const Fraction& b);
    friend Fraction operator*(const Fraction& a, const Fraction& b);
    friend Fraction operator/(const Fraction& a, const Fraction& b);

    void simplify(); // 约分
    void print() const; // 输出分数

private:
    int m_num; // 分子
    int m_den; // 分母
};

Fraction& Fraction::operator=(const Fraction& other) {
    if (this != &other) {
        m_num = other.m_num;
        m_den = other.m_den;
    }
    return *this;
}

Fraction operator+(const Fraction& a, const Fraction& b) {
    Fraction res(a.m_num * b.m_den + b.m_num * a.m_den, a.m_den * b.m_den);
    res.simplify();
    return res;
}

Fraction operator-(const Fraction& a, const Fraction& b) {
    Fraction res(a.m_num * b.m_den - b.m_num * a.m_den, a.m_den * b.m_den);
    res.simplify();
    return res;
}

Fraction operator*(const Fraction& a, const Fraction& b) {
    Fraction res(a.m_num * b.m_num, a.m_den * b.m_den);
    res.simplify();
    return res;
}

Fraction operator/(const Fraction& a, const Fraction& b) {
    Fraction res(a.m_num * b.m_den, a.m_den * b.m_num);
    res.simplify();
    return res;
}

void Fraction::simplify() {
    if (m_den == 0) {
        cerr << "Error: denominator is zero" << endl;
        return;
    }
    if (m_num == 0) {
        m_den = 1;
        return;
    }
    int gcd = 1;
    int a = abs(m_num);
    int b = abs(m_den);
    for (int i = min(a, b); i > 0; --i) {
        if (a % i == 0 && b % i == 0) {
            gcd = i;
            break;
        }
    }
    m_num /= gcd;
    m_den /= gcd;
}

void Fraction::print() const {
    if (m_den == 1) {
        cout << m_num << endl;
    } else {
        int integer = m_num / m_den;
        int numerator = m_num % m_den;
        if (integer != 0) {
            cout << integer << " ";
        }
        cout << numerator << "/" << m_den << endl;
    }
}

这个程序中，我们定义了一个 Fraction 类，包含了两个私有成员变量 m_num 和 m_den，分别表示分子和分母。我们重载了运算符 =、+、-、*、/，并且使用了友元函数实现。

在运算符重载函数中，我们按照分数的加减乘除法规则进行计算，得到结果后调用 simplify() 函数对结果进行约分，最后返回结果。simplify() 函数实现了分数的约分，即求出分子和分母的最大公约数，并将分子和分母都除以这个最大公约数，从而得到最简分数形式。

在 print() 函数中，我们实现了分数的输出，如果分数的分母为 1，则直接输出分子；否则，输出最简分数形式，如果有整数部分，则输出整数部分和分数部分。

您可以在 main() 函数中定义 Fraction 类型的变量，然后进行各种运算，例如：

int main() {
    Fraction a(1, 2);
    Fraction b(2, 3);
    Fraction c = a + b;
    c.print(); // 输出 7/6
    Fraction d = a - b;
    d.print(); // 输出 -1/6
    Fraction e = a * b;
    e.print(); // 输出 1/3
    Fraction f = a / b;
    f.print(); // 输出 3/4
    return 0;
}

在这个例子中，我们定义了两个分数 a 和 b，然后进行加减乘除法运算，并将结果赋值给变量 c、d、e、f，最后调用 print() 函数输出结果。