C++-08-函数重载与运算符重载

函数重载

//函数重载
/*
C++允许在同一作用域中声明几个类似的同名函数，同名函数的形参列表（参数个数，类型，顺序）必须不同，处理实现功能类似数据类型不同的问题
函数重载时指完成不同功能的函数可以具有相同的函数名。
根据函数的实参来确定调用哪一个函数
*/
#include <iostream>
using namespace std;
int add(int a, int b)
{
    cout << "调用整型类型.\n";
    return a + b;
}
int add(char a, char b)
{
    cout << "调用字符型类型.\n";
    return a + b;
}
double add(double a, double b)
{
    cout << "调用双精度型类型.\n";
    return a + b;
}

int main()
{
    cout << "两数相加的结果是:" << add(25, 82) << endl << endl;
    cout << "两数相加的结果是:" << add('A', 'B') << endl << endl;
    cout << "两数相加的结果是:" << add(89.9, 78.1) << endl << endl;
    return 0;
}

运算符重载

//运算符重载
/*
重载的运算符是带有特殊名称的函数，函数名是由关键字operator和其后的要重载的运算符符号组成。

*/
#include <iostream>
using namespace std;
class Box
{
public:
    Box()
    {
        l = 0;
        b = 0;
        h = 0;
    }
    void setl(double length)
    {
        l = length;
    }
    void setb(double breadth)
    {
        b = breadth;
    }
    void seth(double hight)
    {
        h = hight;
    }
    double getv(void)//求体积
    {
        return l * b * h;
    }
    //重载+运算符，用于把两个Box对象进行相加
    Box operator+(const Box& b)
    {
        Box box;
        box.l = this->l + b.l;
        box.b = this->b + b.b;
        box.h = this->h + b.h;
        return box;
    }
private:
    double l;//长度
    double b;//宽度
    double h;//高度
};

int main()
{
    Box box1;//声明box1，类型为Box
    Box box2;
    Box box3;
    double dv = 0.0;//定义存储体积的变量

    //为第一个对象box1赋值
    box1.setl(2.0);
    box1.setb(3.0);
    box1.seth(4.0);

    //为第二个对象box2赋值
    box2.setl(5.0);
    box2.setb(6.0);
    box2.seth(7.0);

    //输出box1的体积
    dv = box1.getv();
    cout << "box1对象的体积为:" << dv << endl << endl;

    //输出box2的体积
    dv = box2.getv();
    cout << "box2对象的体积为:" << dv << endl << endl;

    //把2个对象相加，得到box3
    box3 = box1 + box2;
    
    //输出box3的体积
    dv = box3.getv();
    cout << "box3对象的体积为:" << dv << endl << endl;
    return 0;
}

//运算符重载
//递增++运算符
#include <iostream>
using namespace std;
class CTestSS
{
public:
    CTestSS() :i(0)
    {

    }
    CTestSS operator++()
    {
        cout << "调用前置递增.\n";
        CTestSS obj;
        obj.i = ++i;
        return obj;
    }
    //括号中插入int表示后缀
    CTestSS operator++(int)
    {
        cout << "调用后置递增.\n";
        CTestSS obj;
        obj.i = i++;
        return obj;
    }
    void disp()
    {
        cout << "i=" << i << endl;
    }
private:
    int i;
};

int main()
{
    CTestSS obj1, obj2;
    cout << "输出结果1为:" << endl;
    obj1.disp();
    obj2.disp();

    //调用运算符函数，然后将obj1的值赋给obj2
    obj2 = ++obj1;
    cout << "输出结果2为:" << endl;
    obj1.disp();
    obj2.disp();

    obj2 = obj1++;
    cout << "输出结果3为:" << endl;
    obj1.disp();
    obj2.disp();

    return 0;
}

//运算符重载
//递减--运算符
#include <iostream>
using namespace std;
class CTest
{
public:
    CTest() :x(10)
    {

    }
    CTest operator--()
    {
        cout << "调用前置递减.\n";
        CTest obj;
        obj.x = --x;
        return obj;
    }
    //括号中插入int表示后缀
    CTest operator--(int)
    {
        cout << "调用后置递减.\n";
        CTest obj;
        obj.x = x--;
        return obj;
    }
    void disp()
    {
        cout << "x=" << x << endl;
    }
private:
    int x;
};

int main()
{
    CTest obj1, obj2;
    cout << "输出结果1为:" << endl;
    obj1.disp();
    obj2.disp();

    //调用运算符函数，然后将obj1的值赋给obj2
    obj2 = --obj1;
    cout << "输出结果2为:" << endl;
    obj1.disp();
    obj2.disp();

    obj2 = obj1--;
    cout << "输出结果3为:" << endl;
    obj1.disp();
    obj2.disp();

    return 0;
}