函数重载的回顾（接上一篇文章）：

  • 函数重载的本质为相互独立的不同的函数
  • C++中通过函数名和函数参数确定函数调用
  • 无法直接通过函数名得到重载函数的入口地址
  • 函数重载必然发生在同一个作用域中

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

  • 构造函数的重载
  • 普通成员函数的重载
  • 静态成员函数的重载

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

#include <stdio.h>

class Test
{
        int i;
public:
        Test()
        {
                printf("Test::Test()\n");
                this->i = 0;
        }
        Test(int i)
        {
                printf("Test::Test(int i),i=%d\n",i);
                this->i = i;
        }
        Test(const Test& obj)
        {
                printf("Test(const Test& obj)\n");
                this->i = obj.i;
        }
        static void func()
        {
                printf("void Test::func()\n");
        }
        void func(int i)
        {
                printf("void Test::func(int i),i = %d\n",i);
        }
        
        int getI()
        {
                return i;
        }
};

void func()
{
        printf("void func()\n");
}
void func(int i)
{
        printf("void func(int i),i = %d\n",i);
}

int main()
{
        func();
        func(1);
        
        Test t;        //Test::Test()
        Test t1(1);    //Test::Test(int i)
        Test t2(t1);   //Test(const Test& obj)
        
        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()
        
        return 0;
}

打印结果为：

void func()
void func(int i),i = 1
Test::Test()
Test::Test(int i),i=1
Test(const Test& obj)
void func()
void Test::func()
void func(int i),i = 2
void Test::func(int i),i = 2
void Test::func()

由打印结果我们知道；

1.重载函数的本质为多个不同的函数
2.函数名和参数列表是唯一的标识
3.函数重载必须发生在同一个作用域中

重载的深度意义：

  • 通过函数名对函数功能进行提示
  • 通过参数列表对函数用法进行提示
  • 扩展系统中已经存在的函数的功能

下面分析代码让我们更加深层次的了解函数重载的意义：

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

int main()
{
        const char* s = "Liuyangyang";
        char buf[16] = {0};
        
        strcpy(buf,s);
        
        printf("%s\n",buf);
        
        return 0;
}

打印为：

Liuyangyang

上面这段代码很简单，就是一个拷贝字符串到一个数组中的程序，看起来很简单，但是在现在的软件工程中，这么做还是很容易出错的，因为当定义的buf大小如果不够的话，就会出现内存泄露的情况，所以我们需要对其进行修改。

#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 = "Liuyangyang";
        char buf[8] = {0};
        
        //strcpy(buf,s);
        strcpy(buf,s,sizeof(buf)-1);
        
        printf("%s\n",buf);
        
        return 0;
}

打印结果为：

上面修改后的代码，将strcpy函数进行重载，加入了一个参数，里面返回的strncpy是C语言中的库函数，有人会问为什么我们不直接用这个库函数呢，因为，人们习惯了strcpy，况且strncpy也不是很好记！

总结：

  1. 类的成员函数之间可以进行重载
  2. 重载必须发生在同一个作用域中
  3. 全局函数和成员函数之间不能构成重载关系
  4. 重载的意义在于扩展已经存在的功能

想获得各种学习资源以及交流学习的加我（有我博客中写的代码的原稿）：
qq：1126137994
微信：liu1126137994
可以共同交流关于嵌入式，操作系统，C++语言，C语言，数据结构等技术问题。