29 类中的函数重载

#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()

}

 1 #include<stdio.h>  
 2 
 3 class Test
 4 {
 5     int i;
 6 public: 
 7 
 8     Test()                           //无参构造函数
 9     {
10         printf("Test::Test()\n");
11         this->i = 0;
12     }
13     Test(int i)                      //含参构造函数         
14     { 
15         printf("Test::Test(int i)\n");
16         this->i = 0;
17     }
18     Test(const Test& obj)          //拷贝构造函数
19     {
20         printf("Test::Test(const Test& obj)\n");
21         this->i = obj.i;
22     }
23 
24     static void func()                            //不含参静态成员函数   调用的时候使用类名Test::func();   
25     {
26         printf("void Test::func()\n");
27     }
28     void func(int i)                              //含参成员函数--普通成员函数，调用的时候使用对象t1.func(2)
29     {
30         printf("void Test::func(int i),i=%d\n",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()\n");
43 }
44 void func(int i)                        // 带参全局函数
45 {
46     printf("void func(int i),i=%d\n", 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 }

 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\n", 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\n", buf);
20 
21     return 0;
22 }