C++函数重载（名字相同，参数类型、个数、顺序不一样）

大纲：

1.函数重载（名字相同，参数类型、个数、顺序不一样）
2.typedef定义函数类型（相当于定义了一个函数类型的变量）
3.函数重载和函数指针在一起（调用的时候通过参数区分调用谁）

我们在平时写代码中会用到几个函数但是他们的实现功能相同，但是有些细节却不同。例如：交换两个数的值其中包括（int, float,char,double)这些个类型。在C语言中我们是利用不同的函数名来加以区分。

void Swap1(int* a, int* b);
void Swap2(float* a, float* b);
void Swap3(char* a, char* b);
void Swap4(double* a, double* b);

我们可以看出这样的代码不美观而且给程序猿也带来了很多的不便。于是在C++中人们提出了用一个函数名定义多个函数，也就是所谓的函数重载。

一.函数重载定义

函数重载是一种特殊情况，C++允许在同一作用域中声明几个类似的同名函数，这些同名函数的形参列表（参数个数，类型，顺序）必须不同，常用来处理实现功能类似数据类型不同的问题。

在C++中不仅函数可以重载，运算符也可以重载。例如：

运算符<<,>>。既可以做移位运算符，也可以做输出，输入运算符。

注意：重载函数的参数个数，参数类型或参数顺序三者中必须有一个不同

#include<Windows.h>
#include<iostream>
using namespace std;
 
int Add(int a, int b)
{
	return a + b;
}
 
double Add(double a, double b)
{
	return a + b;
}
 
float Add(float a, float b)
{
	return a + b;
}
int main()
{
	cout<<Add(1,2)<<endl;
	cout<<Add(3.5, 4.5)<<endl;
	cout << Add(2.22, 3.33) << endl;
	system("pause");
	return 0;
}

我们可以看到定义了一个Add函数来求三个不同类型数的和，在调用过程中系统会自动根据其实参的类型不同来实现准确调用。

函数重载的规则：

函数名称必须相同。
参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
函数的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以成为函数的重载。
二、函数重载的作用：
重载函数通常用来在同一个作用域内 用同一个函数名 命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。

三、函数重载是一种静态多态：

（1）多态：用同一个东西表示不同的形态；
（2）多态分为：
静态多态（编译时的多态）；
动态多态（运行时的多态）；
（3）函数重载是一种静态多态；

typedef定义函数类型

其实对于函数，typedef有两类自定义类型：
首先我们要先明白一个概念，函数名是不是指针？也就是说一个函数名可不可以代表一个地址？以及什么是函数类型？

经过查找，函数名就是一个指针，但是意义是不一样的，如同于数组a[]，a和&a其实都是一样的。当调用一个函数时，我们都是直接用函数名调用，或者说通过指针调用。

函数类型，在我理解，就是定义了一个函数返回值类型以及参数类型。

那么：
1.tpyedef自定义函数指针类型：

#include <stdio.h>  
typedef int (*fp_t)(char c);  
  
int f0(char c) { printf("f0, c = %c\n", c); return 0;}  
int f1(char c) { printf("f1, c = %c\n", c); return 1;}  
  
int main()  
{  
        int ret;  
        fp_t fp;  
        fp = f0;  
        ret = fp('a');  
        fp = f1;  
        ret = fp('x');  
        return 0;  
}  

运行结果：
f0, c = a
f1, c = x

2.typedef自定义函数类型：

#include <stdio.h>  
typedef int fp_t(char c);  
  
int f0(char c) { printf("f0, c = %c\n", c); return 0;}  
int f1(char c) { printf("f1, c = %c\n", c); return 1;}  
  
int main()  
{  
        int ret;  
        fp_t* fp;  
        fp = f0;  
        ret = fp('a');  
        fp = f1;  
        ret = fp('x');  
        return 0;  
}  

运行结果：
f0, c = a
f1, c = x

总结：相当于定义一个函数类型的变量，给他赋值，赋的是函数。

函数重载和函数指针在一起

#include <iostream>
using namespace std;

void myfunc(int a)
{
	printf("a:%d \n", a);
}

void myfunc(char *p)
{
	printf("%s \n", p);
}


void myfunc(int a, int b)
{
	printf("a:%d \n", a);
}

void myfunc(char *p1, char *p2)
{
	printf("p1:%s ", p1);
	printf("p2:%s \n", p2);
}

//函数指针 基础的语法
//1声明一个函数类型
typedef void (myTypeFunc)(int a,int b) ;  //int
//myTypeFunc *myfuncp = NULL; //定义一个函数指针 这个指针指向函数的入口地址

//声明一个函数指针类型 
typedef void (*myPTypeFunc)(int a,int b) ;  //声明了一个指针的数据类型 
//myPTypeFunc fp = NULL;  //通过  函数指针类型 定义了 一个函数指针 ,

//定义一个函数指针 变量
void (*myVarPFunc)(int a, int b);
//

void main()
{
	myPTypeFunc fp; //定义了一个 函数指针 变量  

	fp = myfunc;

	fp(1, 2);     //函数重载的调用，也是通过调用的时候，给的参数进行区分
	
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

总结：
-函数重载是C++对C的一个重要升级
-函数重载需要在同一个作用域中
-函数重载通过函数参数列表区分不同的同名函数
-extern关键字能够实现C和C++的相互调用
-编译方式决定符号表中的函数名的最终目标名