C++函数重载(成员函数重载、非成员函数重载)

C++函数重载(成员函数重载、非成员函数重载)

重载的条件

• 作用域相同，函数名相同，参数类型不同，参数个数不同，参数列表顺序不同： 因为符号的生成只有函数名还是有参数有关
• 参数列表相同，返回值不同，不能发生重载；只有当参数列表不同的时候，返回值不同才能发生重载
• 函数参数和默认参数结合，容易出现二义性，导致编译器不知道调用哪个函数

数据类型

int& 和 const int& 用于值传递都是int类型，都可以匹配参数列表为int的类型

 cout << typeid(const int).name() << "-" //int 
         <<typeid(const int *).name() <<"-"  // in const *
         << typeid(int const *).name() <<"-" //int const *
         << typeid(int *).name()<<"-"  //int*
         <<typeid(int&).name()<<"-" // int
         << typeid(const int &).name()<<endl; //int

普通函数重载

//int sum_int_int
int sum(int a, int b)  //如果给b一个默认参值，会导致二义性，使得sum(a);不知道调用哪个重载函数
{
    cout << "int sum_int_int" << endl;
    return a + b;

}
//int sum_const int*_int
int sum(const int* a, int b)
{
    cout << "int sum_const int*_int" << endl;
    return *a + b;

}
//int sum_int*_int
int sum(int* a, int b)
{
    cout << "int sum_int*_int" << endl;
    return *a + b;

}
//int sum_int_double
int sum(int a, double b)
{
    cout << "int sum_int_double" << endl;
    return a + b;

}
//int sum_double_int
int sum(double a, int b)
{
    cout << "int sum_double_int" << endl;
    return a + b;

}
//bool sum a
bool sum(int a)
{
    cout << "bool sum a" << endl;
    return a > 0;
}

int main()
{
    int a = 10;
    int b = 20;
    int* c = &b;
    const int* d = &b;
    sum(a, b);  //int sum_int_int
    sum(c, a);  //int sum_int*_int  如果有int* 优先匹配int*其次才是 const int*
    sum(d, a);  //int sum_const int*_int 
    sum(a, 2.2); //int sum_int_double
    sum(2.2, a); //int sum_double_int
    sum(a);      //bool sum a
    return 0;
}

关于int&和const int& 的重载

• int变量可以匹配 int& 和const int &，优先级是int& > const int&
• int&变量 可以匹配 const int &， 优先级 int& > const int &
• const int &变量不可以匹配 int&
• int & 和const int& 变量都可以匹配int
• 如果存在int的值传递，int & 和 const int&变量都可以匹配，会导致二义性
• 如果没有int类型参数列表，int & 和 const int &可以发送重载

不是很理解为什么参数列表中的int 可以接收 const int &类型

//int sum(int a, int b)   
//如果这个声明存在，会导致二义性，因为int&变量 和const int &变量都可以匹配 int
//{
//    cout << "int sum_int_int" << endl;
//    return a + b;
//
//}
int sum(int& a, int b)
{
    cout << "int sum_int&_int" << endl;
    return a + b;

}
int sum(const int& a, int b)
{
    cout << "int sum_cosnt int&_int" << endl;
    return a + b;
}
int main()
{
    int a = 10;
    int b = 20;
    int& e = a;
    const int& f = a;
    //值传递
     sum(a, b);  //如果定义了int sum_int_int，就是  int sum_int_in
     //优先匹配  int sum_int_int 其次 int sum_int&_int   最后 int sum_cosnt int&_int
    // 引用
    sum(e, b);  // int sum_int&_int  
    sum(f, a);  //int sum_cosnt int&_int   // const int& 不能匹配参数列表里面的int&  
    // const int& 和 int& 的参数都可以匹配int的函数
    return 0;
}

成员函数

1. 普通成员函数 : void func(int a);
2. virtual虚函数 : virtual void func(int a);
3. const成员函数 : void func(int a)const；
4. 静态成员函数 :static void func(int a);

• 1和2是重定义
• 1和4会报错, static 不可以作为重载标志，如果参数不同可以进行重载(排除普通成员函数this指针的参数)

  cannot overload static and non-static member functions with the same parameter types
  不能重载具有相同参数类型的静态和非静态成员函数

• 3和1可以发送重载

  本质是： 参数类型不同

  • void func(int a) < = > void func(Base * this, int a);
  • void func(int a)const < = > void func(const Base *this, int a) const

若有错误请及时指出！