C++之过载函数

过载函数的定义：
用同一个函数名定义不同的函数
当函数名和不同的参数搭配时函数的含义不同

过载函数的判断标准：
函数重载至少满足下面的一个条件：
参数个数不同
参数类型不同
参数顺序不同
函数返回值不是函数重载的判断标准

调用重载函数的准则：
将所有同名函数作为候选者
尝试寻找可行的候选函数：
1 )精确匹配实参
2) 通过默认参数能够匹配实参
3) 通过默认类型转换匹配实参
匹配失败：
1) 最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。
2) 无法匹配所有候选者，函数未定义，编译失败。

注意事项：
重载函数在本质上是相互独立的不同函数（静态链编）
重载函数的函数类型是不同的
函数返回值不能作为函数重载的依据
函数重载是由函数名和参数列表决定的。

函数重载和函数指针：
当使用重载函数名对函数指针进行赋值时：
根据重载规则挑选与函数指针参数列表一致的候选者
严格匹配候选者的函数类型与函数指针的函数类型

#include <stdio.h>

void print_int(int a)
{
    printf ("a = %d\n", a);
}

void print_char(char c)
{
    printf ("c = %c\n", c);
}

void print_str(char *str)
{
    printf ("str = %s\n", str);
}

// 函数重载：函数名相同，函数的参数不一样，根据调用的时候传的参数类型
// 决定调用哪一个函数
void printA(int a)
{
    printf ("a = %d\n", a);
}

// 参数个数不同
void printA(int a, int b)
{
    printf ("a = %d, b = %d\n", a, b);
}

// 函数重载遇上函数默认参数可能导致 二义性的问题
void printA(int a, int b,int c)
{
    printf ("a = %d, b = %d, c = %d\n", a, b, c);
}

void printA(int a, char *str)
{
    printf ("a = %d, str = %s\n", a, str);
}

void printA(char *str, int a)
{
    printf ("a = %d, str = %s\n", a, str);
}

void printA(char c)
{
    printf ("c = %c\n", c);
}

void printA(char *str)
{
    printf ("str = %s\n", str);
}

// 函数重载的规则：1、参数个数不同 2、参数类型不同 3、参数顺序不同

// 函数的返回值不能作为函数重载的判定条件
//int printA(int a)
//{
//
//}

int main9_2()
{
    int a = 10;
    char c = 'a';
    char *str = "hello";
    // printA(10, 20);
    printA(10,20,30);
    printA(a);
    printA(c);
    printA(str);

    return 0;
}

int main9_1()
{
    int a = 10;
    char c = 'a';
    char *str = "hello";

    print_int(a);
    print_char(c);
    print_str(str);

    return 0;
}

// 对于引用，常量性不同可以作为重载的条件
int sub(int &a, int &b)
{
    return a - b;
}

int sub(const int &a, const int &b)
{
    return  a - b;
}

int main9_3()
{
    sub(10, 20);
    int a = 10;
    int b = 20;
    sub(a, 10);

    return 0;
}


// 定义一个函数指针类型，有一个 void 返回值，和一个 int 类型的形参
typedef void (*PFUNC)(int);

int main()
{
    // 当将一个重载函数赋给一个函数指针的时候
    // 严格匹配函数指针的类型
    PFUNC pfunc = printA;

    pfunc(10);
    return 0;
}