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;
}

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

编译程序能够对是否存在冲突与二义性作出判断的依据，是类型及其操作集。

方法

运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。从某种程度上看，运算符重载也是函数的重载。但运算符重载的关键并不在于实现函数功能，而是由于每种运算符都有其约定俗成的含义，重载它们应是在保留原有含义的基础上对功能的扩展，而非改变。

一般格式

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

{

对运算符的重载处理

}

operator是c++的关键字，专门用于定义重载运算符的函数。

operator运算符名称****就是函数名，表示对该运算符的重载。

omplex operator+ (Complex& c1,Complex& c2);

//将"+"用于Complex类(复数)的加法运算，函数的原型

当重载函数是类中的成员函数，有一个参数是隐含的，函数是用this指针隐式地访问类对象的成员。

c3=c1+c2

最后在C++编译系统中被解释为：

c3=c1.operator+(c2)

在此例中，operator+是类的成员函数。第一操作数为"*this（c1）"，第二操作数为"参数（c2）"。

实质

操作符的重载就是函数的重载，在程序编译时把指定的运算表达式转换成对运算符的调用，把运算的操作数转换成运算符函数的参数，根据实参的类型决定调用哪个操作符函数。

基本前提/规则

1.只能为自定义类型重载操作符；

2.不能对操作符的语法(优先级、结合性、操作数个数、语法结构) 、语义进行颠覆；

3.不能引入新的自定义操作符；

4.重载运算符的函数不能有默认的参数；

5.重载运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象（或类对象的引用）；

6.用于类对象的运算符一般必须重载，但有两个例外，"="和"&"不必用户重载；

7.应当使重载运算符的功能类似于该运算符作用于标准类型数据时候时所实现的功能。

8.运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数，也不是友元函数的普通函数。

可重载运算符

不可重载运算符

全局重载

友元重载

成员重载

赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）运算符必须是成员（函数）。

双目运算符重载------全局两参，成员一参

+= 、-=

单目运算符重载------全局一参，成员无参

前++

后++

输入输出运算符重载

<<、>>

友员还是成员

1.一个操作符的左右操作数不一定是相同类型的对象，这涉及到将该操作符函数定义为谁的友员，谁的成员问题。

2.一个操作符函数，被声明为哪个类的成员，取决于该函数的调用对象（通常是左操作数）

3.一个操作符函数，被声明为哪个类的友员，取决于该函数的参数对象（通常是右操作数）

赋值运算符重载

用一个已有对象，给另外一个已有对象赋值。两个对象均已创建结束后，发生的赋值行为。

类名

{

类名& operator=(const 类名& 源对象) 拷贝体

}

class A

{

A& operator=(const A& another){

函数体

return *this；

}

};

规则

1.系统提供默认的赋值运算符重载，一经实现，不复存在。

2.系统提供的也是等位拷贝，也就是浅拷贝，一个内存泄漏，重析构。

3.要实再深深的赋值，必须自定义。

4.自定义面临的问题有三个：

a.自赋值

b.内存泄露

c.重析构

5.返回引用，且不能用const析构。其目的是实现连等式。

数组下标运算符（operator[]）

类型 类::operator[](类型);

设x是类X的一个对象，则表达式x[y]

可被解释为x.operator[](y)

函数调用符号（operator()）

把类对象像函数名一样使用。

仿函数，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator()，这个类就有了类似函数的行为，就是一个仿函数类了。

class 类名{

返回值类型 operator()(参数类型) 函数体

}

不可重载&&和||操作符

->和*重载格式