C++ 重载

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明

是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

重载声明

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

函数重载

函数名相同，参数列表(参数个数、参数类型、参数顺序)相同，函数返回值相同，称为函数重定义；

函数名相同，参数列表(参数个数、参数类型、参数顺序)不同，称为函数重载。

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。不能仅通过返回类型的不同来重载函数。

#include <iostream>
using namespace std;
class printData
{
    public:
    void print(int i) {
        cout << "整数为: " << i << endl;
    }
    void print(double  f) {
        cout << "浮点数为: " << f << endl;
    }
    void print(char c[]) {
        cout << "字符串为: " << c << endl;
    }
};
int main(void)
{
    printData pd;   // 输出整数
    pd.print(5);     // 输出浮点数
    pd.print(500.263);   // 输出字符串
    char c[] = "Hello C++";
    pd.print(c);
    return 0;
}

重载规则

1.函数名相同

2.参数个数不同，参数的类型不同，参数顺序不同，均可构成重载

3.返回值类型不同则不可以构成重载【函数的返回值类型可以不同，但是两个函数只是返回返回值类型不同，不可重载】

调用准则

1.严格匹配，找到则调用

2.通过隐式转换寻求一个匹配，找到则调用

如果能够严格匹配，调用完全匹配的

如果没有完全匹配，调用隐士匹配的

以上都匹配不到的，调用失败。

编译器调用重载函数的准则

1.将所有同名函数作为候选者

2.尝试寻求可行的候选函数

3.精确匹配实参

4.通过默认参数能够匹配实参

5.通过默认类型转换匹配实参

6.匹配失败

7.最终寻找到的可行候选函数不唯一，则出现二义性，编译失败

8.无法匹配所有候选者，函数未定义，编译失败

重载底层实现

C++利用name mangling（倾轧）技术，来改名函数，区分参数不同的同名函数。

实现原理

用v c i f l d表示void char int float long double及其引用

void func(char a); //func_c(char a)

void func(char a,int b,double c); //func_cid(char a,int b,double c)

函数重载与函数默认参数

一个函数，不能既作重载，又作默认参数的函数。当你少写一个参数时，系统无法确认是重载还是默认参数。

函数重载与函数指针结合

实际上，在给函数指针赋值的时候，是会发生函数重载匹配的，在调用函数指针的时候，所调用的函数就已经固定了。而普通的重载，是在函数调用的时候进行匹配的。

函数指针：指向函数的指针

函数重载总结

1.重载函数在本质上是相互独立的不同函数

2.函数的函数类型是不同的

3.函数返回值不能作为函数重载的依据

4.函数重载是由函数名和参数列表决定的

友元函数

友元函数是一种对面对对象程序中类的破坏，可以访问私有成员。

一般格式

加friend关键字即可

重载运算符

friend函数类型 operator 运算符名称 (形参表列)

{

对运算符的重载处理

}

运算符重载

借助类中的成员函数完成。

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的【二者之间没有空格】。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

返回值类型 operator运算符(参数列表);

对象运算符对象；对象运算符常数；常数运算符对象

第一个参数是对象，可以使用全局、友元、成员，推荐使用成员函数重载。

第一个参数是常数，跨源使用全局、友元。

友元函数重载，可以说是介于成员函数重载和全局函数重载之间。

对象作为参数进行传递，对象的属性使用 this 运算符进行访问，如下所示：

作为全局函数使用

#include<iostream>
using namespace std;
class A {
public:
	A(int a, int b) {
		this->a = a;
		this->b = b;
	}
	void printA() {
		cout << "(" << this->a << "," << this->b << ")" << endl;
	}
	friend A operator+(A& c1, A& c2);
private:
	int a;
	int b;
};
A operator+(A& c1, A& c2) {                         //全局函数
	A temp(c1.a + c2.a, c1.b + c2.b);
	return temp;
}
int main() {
	A c1(1, 2);
	A c2(3, 4);
	c1.printA();
	c2.printA();
	A c3 = opertor + (c1, c2);  //等价于 A c3=c1+c2;
	c3.printA();
        return 0;
}

作为类成员函数

#include<iostream>
using namespace std;
class A {
public:
	A(int a, int b) {
		this->a = a;
		this->b = b;
	}
	void printA() {
		cout << "(" << this->a << "," << this->b << ")" << endl;
	}
	A operator+(A& another) {          //类内成员函数
		A temp(this->a + another.a, this->b + another.b);
		return temp;
	}
private:
	int a;
	int b;
};
int main() {
	A c1(1, 2);
	A c2(3, 4);
	c1.printA();
	c2.printA();
	A c3=c1.operator+(c2);  //等价于 A c3=c1+c2;
	c3.printA();
	return 0;
}

在用户自定义类型中使用操作符来表示所提供的某些操作，可以收到同样的效果，但前提是它们与基本类型用操作符表示的操作、与其他用户自定义类型用操作符表示的操作之间不存在冲突与二义性。(即在某一特定位置上，某一操作符应具有确定的、唯一的含义)
编译程序能够对是否存在冲突与二义性作出判断的依据，是类型及其操作集。