【C++深度剖析学习总结】 22 类中的函数重载

1.函数重载回顾

函数重载的本质为相互独立的不同函数

C++中通过函数名和函数参数确定函数调用

无法直接通过函数名得到重载函数的入口地址

函数重载必然发生在同一个作用域中

2.类中的重载

类中的成员函数可以进行重载

构造函数的重载

普通成员函数的重载

静态成员函数的重载

问题：全局函数，普通成员函数以及静态成员函数之间是否可以构成重载？

3.万变不离其宗

1.重载函数的本质为多个不同的函数

2.函数名和参数列表是唯一的表示

3.函数重载必须发生在同一个作用域中 （类和全局就不行，因为作用域已经不同了）

4.深度的意义---现在提倡代码自助式，即不需要注释来说明如何调用

重载的意义

通过函数名对函数功能进行提示

通过参数列表对函数用法进行提示

扩展系统中已经存在的函数功能

  

   

    

     

    
    

     

      #include <iostream>
     
    
   

    

     

    
    

     

      using namespace std;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      template<class T> void Swap(T &a, T &b);  //模板①：交换基本类型的值
     
    
   

    

     

    
    

     

      template<typename T> void Swap(T a[], T b[], int len);  //模板②：交换两个数组
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      void printArray(int arr[], int len);  //打印数组元素
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      int main(){
     
    
   

    

     

    
    

     
    //交换基本类型的值
     
    
   

    

     

    
    

     
    int m = 10, n = 99;
     
    
   

    

     

    
    

     
    Swap(m, n);  //匹配模板①
     
    
   

    

     

    
    

     

          cout<<m<<", "<<n<<endl;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    //交换两个数组
     
    
   

    

     

    
    

     
    int a[5] = { 1, 2, 3, 4, 5 };
     
    
   

    

     

    
    

     
    int b[5] = { 10, 20, 30, 40, 50 };
     
    
   

    

     

    
    

     
    int len = sizeof(a) / sizeof(int);  //数组长度
     
    
   

    

     

    
    

     
    Swap(a, b, len);  //匹配模板②
     
    
   

    

     

    
    

     
    printArray(a, len);
     
    
   

    

     

    
    

     
    printArray(b, len);
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    return 0;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      template<class T> void Swap(T &a, T &b){
     
    
   

    

     

    
    

     

          T temp = a;
     
    
   

    

     

    
    

     

          a = b;
     
    
   

    

     

    
    

     

          b = temp;
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      template<typename T> void Swap(T a[], T b[], int len){
     
    
   

    

     

    
    

     

          T temp;
     
    
   

    

     

    
    

     
    for(int i=0; i<len; i++){
     
    
   

    

     

    
    

     

              temp = a[i];
     
    
   

    

     

    
    

     

              a[i] = b[i];
     
    
   

    

     

    
    

     

              b[i] = temp;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      void printArray(int arr[], int len){
     
    
   

    

     

    
    

     
    for(int i=0; i<len; i++){
     
    
   

    

     

    
    

     
        if(i == len-1){
     
    
   

    

     

    
    

     

                  cout<<arr[i]<<endl;
     
    
   

    

     

    
    

     

              }else{
     
    
   

    

     

    
    

     

                  cout<<arr[i]<<", ";
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  
 

小结

类的成员函数之间可以进行重载

重载必须发生在同一个作用域中

全局函数和成员函数不能构成重载关系

重载的意义在于扩展已经存在的功能

文章来源: allen5g.blog.csdn.net，作者：CodeAllen的博客，版权归原作者所有，如需转载，请联系作者。

原文链接：allen5g.blog.csdn.net/article/details/117400800