29 类中的函数重载

Posted liuyueyue

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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. 类中的函数重载

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

  • 构造函数重载

  • 普通成员函数重载

  • 静态成员函数重载

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

 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)重载意义在于扩展已经存在的功能

以上是关于29 类中的函数重载的主要内容,如果未能解决你的问题,请参考以下文章

C++学习29 重载[](下标运算符)

类中的函数重载

为啥派生类中的重写函数会隐藏基类的其他重载?

为啥派生类中的重写函数会隐藏基类的其他重载?

为啥派生类中的重写函数会隐藏基类的其他重载?

类中的函数重载