29 类中的函数重载

Posted 2020-12-18 liuyueyue

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. 类中的函数重载

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

• 构造函数的重载

• 普通成员函数的重载

• 静态成员函数的重载

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

 1 #include<stdio.h>  
 2 
 3 class Test
 4 {
 5     int i;
 6 public: 
 7 
 8     Test()                           //无参构造函数
 9     {
10         printf("Test::Test()
");
11         this->i = 0;
12     }
13     Test(int i)                      //含参构造函数         
14     { 
15         printf("Test::Test(int i)
");
16         this->i = 0;
17     }
18     Test(const Test& obj)          //拷贝构造函数
19     {
20         printf("Test::Test(const Test& obj)
");
21         this->i = obj.i;
22     }
23 
24     static void func()                            //不含参静态成员函数   调用的时候使用类名Test::func();   
25     {
26         printf("void Test::func()
");
27     }
28     void func(int i)                              //含参成员函数--普通成员函数，调用的时候使用对象t1.func(2)
29     {
30         printf("void Test::func(int i),i=%d
",i);
31     }
32     int getI()
33     {
34         return i;
35     }
36 };
37 
38 //全局函数void func() 和不含参成员函数static void func()  作用域不同  不属于重载函数
39 
40 void func()                              //无参全局函数-----全局函数位于全局命名空间
41 {
42     printf("void func()
");
43 }
44 void func(int i)                        // 带参全局函数
45 {
46     printf("void func(int i),i=%d
", i);
47 }
48 
49 int main()
50 {
51     //使用函数名和参数列表能确定唯一调用哪个函数
52 
53     func();                  //调用无参全局函数      void func()
54     func(1);                 //调用 带参全局函数      void func(int i),i=1
55 
56     Test t;                    //调用类内无参构造函数     Test::Test()
57     Test t1(1);                //调用类内带参构造函数     Test::Test(int i)
58     Test t2(t1);               //用t1对象去初始化t2   调用类内拷贝构造函数     Test::Test(const Test& obj)
59                                //等价于Test t2 = t1;    
60 
61 
62     func();                 //调用无参全局函数              void func()
63     Test::func();           //调用类内含参成员函数          void Test::func()
64 
65     func(2);                   //调用带参全局函数              void func(int i),i=2
66     t1.func(2);                //调用类内含参成员函数         void Test::func(int i),i=2
67     t1.func();                   //调用类内含参成员函数          void Test::func()
68 
69     //func(2)属于类内普通成员函数，通过对象直接调用
70     //func(）属于类内静态成员函数 ，类名和对象调用
71 
72     return 0;
73 }

3. 重载的深度意义

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

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

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

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

存在问题：

 1 #include<stdio.h>  
 2 #include<string.h>  
 3 
 4 //重载意义分析
 5 
 6 int main()
 7 {
 8     const char* s = "i.love.you";   //设置字符串
 9     char buf[16] = { 0 };           //将字符串s拷贝到buffer先初始化为0
10   
11     //strcpy_s(buf, s); //存在问题-------若buf大小设置不够，就是发生内存越界 char buf[8] = { 0 };   会产生bug
12 
13     //怎么处理？
14     strncpy(buf, s, sizeof(buf) - 1);  //将拷贝大小最多设置为sizeof(buf) - 1
15     //但是这样增加了一个函数，strncpy还不好记 
16 
17     printf("%s
", buf);
18 
19     return 0;
20 }
21 
22 接下来通过函数重载扩展strncpy------将之前的strcpy_s扩展为三个参数

重载之后：

 1 #include<stdio.h>  
 2 #include<string.h>  
 3 
 4 
 5 char* strcpy(char* buf, const char* str, unsigned int n) //重载函数
 6 {
 7     return strncpy(buf, str, n);
 8 }
 9 
10 int main()
11 {
12     const char* s = "i.love.you";   //设置字符串
13     char buf[16] = { 0 };           //将字符串拷贝到buffer先初始化为0
14                                     //若buf大小设置不够，就是发生内存越界 char buf[8] = { 0 };            会产生bug
15 
16 //    strcpy(buf, s);
17     strcpy(buf, s, sizeof(buf) - 1); //使用函数重载扩展了strcpy_s的功能 两个参数变成三个参数
18 
19     printf("%s
", buf);
20 
21     return 0;
22 }

4. 小结

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

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

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