---

c++函数重载与运算符重载

函数重载

函数重载是一种特殊情况，c++允许在同一作用域中声明几个类似的同名函数，这些同名函数的形参列表(参数个数，类型，顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。所谓的函数重载是指完成不同功能的函数可以具有相同的函数名。c++的编译器是根据函数的实参来确定应该调用哪一个函数的。

#include <iostream>
using namespace std;

class CNewDelete {
public:
private:
};

int add(int a, int b) {
    cout << "调用整型类型.";
    return a + b;
};
float add(float a, float b) {
    cout << "调用浮点型类型.";
    return a + b;
};
double add(double a,double b) {
    cout << "调用双精度型.";
    return a + b;
};
int add(char a, char b) {
    cout << "调用字符型.";
    return a + b;
};
int main() {
    cout << "两数相加："<< add(25,25) << endl;
    cout << "两数相加：" << add('A', 'B') << endl;
    cout << "两数相加：" << add(1.5,1.5) << endl;
    cout << "两数相加：" << add(3.1415926, 3.1415926) << endl;
    return 0;
}

运算符重载

可以重定义活重载大部分c++内置的运算符，这样就可以使用自定义类型的运算符，重载的运算符是带有特殊名称的函数，函数名是由关键字operator和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和参数列表，格式如下：

Box operator+(const Box&);

声明加法运算符用于把两个Box对象相加，返回最终的Box对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，如下格式：

Box operator+(const Box&,const Box&);

在c++中，允许重载的运算符如下

在c++中，不允许重载的运算符

- .		成员访问运算符
- .*, ->*	成员指针访问运算符
- ::		域运算符
- sizeof	长度运算符
- ?:		条件运算符
- #		预处理符号

重载运算符和重载函数

一元运算符只对一个操作数进行操作，下面是一元运算符的实例；

- 递增运算符(`++`)和递减运算符(`--`)
- 一元运算符，即负号(`-`)
- 逻辑非运算符(`!`)

一元运算符通常出现在他们所操作的对象的左边，比如!obj、-obj、++obj、但有时它们也可以作为后缀，比如obj++、obj--;

二元运算符重载

二元运算符需要两个参数【+、-、*、/】都属于二元运算符。

运算符+号进行重载运行相加

#include <iostream>
using namespace std;
class Box {
private:
    double l; // 长
    double b; // 宽
    double h; // 高
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;
    }
};
int main() {
    Box box1; // 声明box1，类型为Box对象
    // 为第一个对象赋值
    box1.setl(2.0);
    box1.setb(3.0);
    box1.seth(4.0);
    Box box2;
    // 为第二个对象赋值
    box2.setl(5.0);
    box2.setb(6.0);
    box2.seth(7.0);
    double dv = 0.0; // 存储体积变量
    dv = box1.getv();
    cout << "box1对象的体积为：" << dv << endl << endl;

    dv = box2.getv();
    cout << "box2对象的体积为：" << dv << endl << endl;

    // 把两个对象相加，得到box3
    Box box3;
    box3 = box1 + box2;
    dv = box3.getv();
    cout << "box3对象的体积为：" << dv << endl << endl; // (2 + 5)*(3+6)*(4+7)
    return 0;
}

++和–运算符重载

递增运算符++和递减运算符--是c++开发中重要的一元运算符。

#include <iostream>
using namespace std;
class CTestSS {
private:
    int i;
public:
    CTestSS():i(0) {
    
    }
    CTestSS operator++() {
        cout << "调用前置递增.\n";
        CTestSS obj;
        obj.i = ++i;
        return obj;
    }
    CTestSS operator++(int) { //括号中插入int表示后缀
        cout << "调用后置递增.\n";
        CTestSS obj;
        obj.i = i++;
        return obj;
    }
    void disp() {
        cout << "i=" << i << endl;
    }
};
int main() {
    CTestSS obj1, obj2;
    cout << "\n\n输出结果1为：" << endl;
    obj1.disp();
    obj2.disp();
    // 调用运算符函数，然后将obj1的值赋给obj2
    obj2 = ++obj1;
    cout << "\n\n输出结果2为：" << endl;
    obj1.disp();
    obj2.disp();


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

    return 0;
}

--运算符重载

#include <iostream>
using namespace std;
class CTest {
private:
    int x;

public:
    CTest() :x(10) {
    
    };
    CTest operator--(){
        CTest obj;
        obj.x = --x;
        return obj;
    }
    // 括号中插入int参数，表示后缀计算方式
    CTest operator--(int) {
        CTest obj;
        obj.x = x--;
        return obj;
    }
    void Disp() {
        cout << "x=" << x << endl;
    }
};
int main() {
    CTest obj1, obj2;
    cout << "\n结果1为：" << endl;
    obj1.Disp();
    obj2.Disp();

    obj2 = --obj1;
    cout << "\n结果2为：" << endl;
    obj1.Disp();
    obj2.Disp();
    
    obj2 = obj1--;
    cout << "\n结果3为：" << endl;
    obj1.Disp();
    obj2.Disp();
    return 0;
}