29 类中的函数重载

1. 函数重载的回顾-----同一个函数名定义不同函数（互不相同的函数，共享一个函数名）

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

（2）C++中通过函数名和函数参数确定函数调用，函数名和参数列表组成唯一的标识

（3）无法直接通过函数名得到重载函数的入口地址-------重载函数的入口地址不同

（4）函数重载必然发生在同一个作用域----一个类内部

【编程实验】类成员函数指针

#include <iostream>
using namespace std;

class Test
{
public:
   void show()
   {
       cout <<"Test::show()" << endl;
   }
  
   void print()
   {
       cout <<"Test::print()" << endl;
   }
};
 
//声明类成员函数指针
typedef void (Test::* PFunc)();

int main()
{
   Test t;
   PFunc p = t.show;

   (t.*p)();     //Test::show()
  
   p = t.print;

   (t.*p)();      //Test::print()
}

2. 类中的函数重载

——类中成员函数可以进行重载-------关键：注意考虑在同一个作用域

• 构造函数的重载

• 普通成员函数的重载

• 静态成员函数的重载

全局函数、普通成员函数、静态成员函数能不能构成函数重载？？？

#include<stdio.h>  

class Test
{
    int i;
public: 

    Test()                           //无参构造函数
    {
        printf("Test::Test()
");
        this->i = 0;
    }
    Test(int i)                      //含参构造函数         
    { 
        printf("Test::Test(int i)
");
        this->i = 0;
    }
    Test(const Test& obj)             //拷贝构造函数
    {
        printf("Test::Test(const Test& obj)
");
        this->i = obj.i;
    }

    static void func()                            //不含参静态成员函数   调用的时候使用类名Test::func();   
    {
        printf("void Test::func()
");
    }
    void func(int i)                              //含参成员函数--普通成员函数，调用的时候使用对象t1.func(2)
    {
        printf("void Test::func(int i),i=%d
",i);
    }
    int getI()
    {
        return i;
    }
};

//全局函数void func() 和不含参成员函数static void func()  作用域不同  不属于重载函数

　　void func()                              //无参全局函数-----全局函数位于全局命名空间
　　{
 　　   printf("void func()
");
　　}
　　void func(int i)                        // 带参全局函数
　　{
 　　   printf("void func(int i),i=%d
", i);
　　}

int main()
{
    //使用函数名和参数列表能确定唯一调用哪个函数

    func();                  //调用无参全局函数      void func()
    func(1);                 //调用 带参全局函数      void func(int i),i=1

    Test t;                    //调用类内无参构造函数     Test::Test()
    Test t1(1);                //调用类内带参构造函数     Test::Test(int i)
    Test t2(t1);               //用t1对象去初始化t2   调用类内拷贝构造函数     Test::Test(const Test& obj)
                               //等价于Test t2 = t1;    


    func();                 //调用无参全局函数              void func()
    Test::func();           //调用类内含参成员函数          void Test::func()

    func(2);                   //调用带参全局函数              void func(int i),i=2
    t1.func(2);                //调用类内含参成员函数         void Test::func(int i),i=2
    t1.func();                 //调用类内含参成员函数          void Test::func()

    //func(2)属于类内普通成员函数，通过对象直接调用
    //func(）属于类内静态成员函数 ，类名和对象调用

    return 0;
}

3. 重载的深度意义

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

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

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

（4）扩展其他更多的功能

存在问题：

#include<stdio.h>  
#include<string.h>  

//重载意义分析

int main()
{
    const char* s = "i.love.you";   //设置字符串
    char buf[16] = { 0 };           //将字符串s拷贝到buffer先初始化为0
  
    //strcpy_s(buf, s); //存在问题-------若buf大小设置不够，就是发生内存越界 char buf[8] = { 0 };   会产生bug

    //怎么处理？
    strncpy(buf, s, sizeof(buf) - 1);  //将拷贝大小最多设置为sizeof(buf) - 1
    //但是这样增加了一个函数，strncpy还不好记 

    printf("%s
", buf);

    return 0;
}

接下来通过函数重载扩展strncpy------将之前的strcpy_s扩展为三个参数

重载之后：

#include<stdio.h>  
#include<string.h>  


char* strcpy(char* buf, const char* str, unsigned int n)   //重载函数
{
    return strncpy(buf, str, n);
}

int main()
{
    const char* s = "i.love.you";   //设置字符串
    char buf[16] = { 0 };           //将字符串拷贝到buffer先初始化为0
                                    //若buf大小设置不够，就是发生内存越界 char buf[8] = { 0 };            会产生bug

//    strcpy(buf, s);
    strcpy(buf, s, sizeof(buf) - 1); //使用函数重载扩展了strcpy_s的功能 两个参数变成三个参数

    printf("%s
", buf);

    return 0;
}

4. 小结

（1）类的成员函数之间可以重载

（2）重载必须发生在同一个作用域中（全局函数和成员函数不能构成重载关系）

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