c++ 的命名空间、重载（为什么C++支持重载，C语言不支持重载）和缺省参数的用法总结

前言

C语言几乎是c++的一个子集，所以C语言支持的语法在c++基本都支持并且需要使用。但是c++在c语言的基础上又多了很多新特性。这篇博客主要对比C语言的一些语法缺陷来介绍c++（命名空间和重载，函数的缺省参数）的语法新特性。

命名空间

C语言中的命名

在C语言中一下代码会报出命名冲突、变量a重定义的错

int main()
{
    int a = 10;
    int a = 20;
    return 0;
}

但是下段代码就没有错误，因为两个变量a定义的域不同

int a = 10;
int main()
{
    int a = 20;
    return 0;
}

再看C语言中的下段代码，这个时候很多人就蒙了，这个变量a的输出值到底是多少呢？是全局变量a=10?还是局部变量a=20?这里就会出现歧义。其实答案是20，因为采取就近原则。这一点就可以说明C语言语法在命名这一方面的缺陷，但是在c++语言中就有很好的解决这一缺陷的语法—–命名空间

int a = 10;
int main()
{
    int a = 20;
    printf("%d\n", a);
    return 0;
}

c++命名空间

命名空间的基本用法

命名空间域是随标准c++而引入的。它相当于一个更加灵活的文件域（全局域），可以用花括号把文件的一部分括起来，并以关键字namespace开头给它起一个名字：

namespace name1{
    int a = 10;
}
namespace name2{
    int a = 20;
}
int main()
{
    cout << name1::a << endl;
    cout << name2::a << endl;
    return 0;
}

如上段代码，分别给a命名了空间域，在我们访问的时候就很明确的知道，访问的是那个域里的变量。命名空间域解决了全局命名冲突的问题。
::是作用域解析符
假如说我们在代码中经常用到name2命名空间中的变量a，但是每次用都要加name2::很麻烦，我们可以写一个using指示符：using namespace name2;就可以直接用name2里面的所以成员变量，如下操作：

namespace name1{
    int a = 10;
}
namespace name2{
    int a = 20;
}
using namespace name2;
int main()
{
    cout << name1::a << endl;
    cout << a << endl;
    return 0;
}

嵌套的命名空间

命名空间支持嵌套，我们可以再命名空间中嵌套一个函数

namespace name{
    int a=10;
    int b = 10;
    namespace my
    {
        int max(int a, int b)
        {
            return a > b ? a : b;
        }
    }
}
int main()
{
    std::cout <<name::my::max(3,4) << std::endl;
    return 0;
}

标准c++库中所有组件的命名空间

标准c++库中所有组件（如cout,cin,endl等）都是在一个被称为std的命名空间中声明和定义的，在采用标准c++的平台上使用标准c++库中的组件，只要写一个：using namespace std;就可以直接使用标准c++库中的成员，或者std::+成员的方式也可以。如下：

//方法一
using namespace std;
int main()
{
  cout<<"Hello HL"<<endl;
  return 0;
}

//方法二
int main()
{
  std::cout<<"Hello HL"<<std::endl;
  return 0;
}

上面两种输出结果相同，但是方法二的写法更加规范，防止命名空间污染。

C++函数重载

什么是函数重载

在同一个作用域内，一组函数的函数名相同，参数列表不同（参数个数不同/参数类型不同），返回值可以相同也可以不相同。如下面例子：

//c++
void Func(int a)
{
    cout << a << endl;
}
void Func(char b)
{
    cout << b << endl;
}
int main()
{
    int a = 10;
    char b = 'b';
    Func(a);
    Func(b);
    system("pause");
    return 0;
}

//c语言
#include<stdio.h>
void Func(int a)
{
    printf("%d\n", a);
}
void Func(char b)
{
    printf("%c\n", b);
}
int main()
{
    int a = 10;
    char b = 'b';
    Func(a);
    Func(b);
    system("pause");
    return 0;
}

在C语言中，不支持函数重载，会出现链接错误。

为什么c++支持函数重载，C语言不支持

在程序运行过程中，会经过预处理、编译、汇编、链接四个阶段，C语言在进行重载的时候可以通过前三个阶段，但是链接不通过，因为在链接的过程中main函数是通过call指令找函数名字来完成链接的（在Linux下使用objdump查看目标文件中的函数名字的修饰，来比较函数重载在c++和C语言中的不同）

观察C语言和c++目标文件中的函数名字的不同，在C语言中目标文件中的函数名就是函数名，所以在链接的时候如果有两个函数名相同的函数就会出现访问冲突。但是在c++中目标文件中的函数名由它的函数名、函数参数共同构成，所以在链接的时候只要函数参数不同就可以访问到相应函数，从而不会发生访问冲突的问题。

//C语言
#include<stdio.h>
void Func(int i,char* p,double d)
{
        int j = 0;
        printf("Func int char* double\n");
}
int main()
{
        int a = 10;
        char b = 'b';
        Func(10,(char*)10,10);
        return 0;
}

//c++
#include<stdio.h>
void Func(int i,char* p,double d)
{
    int j = 0;
    printf("Func int char* double\n");
}
void Func(char i)
{
    printf("Func int\n");
}
int main()
{
    int a = 10;
    char b = 'b';
    Func(10,(char*)10,10);
    Func('A');
    return 0;
}

缺省参数

缺省参数，就是在声明函数的某个参数的时候为之指定一个默认值，在调用该函数的时候如果采用该默认值，你就无须指定该参数。缺省参数使用主要规则:调用时你只能从最后一个参数开始进行省略，换句话说，如果你要省略一个参数，你必须省略它后面所有的参数，即:带缺省值的参数必须放在参数表的最后面。 缺省值必须是常量。 缺省参数必须通过值参或常参传递。声明是带有缺省参数的函数，则缺省值只能写在声明当中。

全缺省参数

#include <iostream>
using namespace std;
int Add(int a = 10, int b = 20)
{
    return a + b;
}
int main()
{
    int ret1 = Add();
    int ret2 = Add(20);//这里省略的是b传参
    cout << ret1 << endl;
    cout << ret2 << endl;
    return 0;
}

半缺省参数

#include <iostream>
using namespace std;
int Add(int a , int b=20)
{
    return a + b;
}
int main()
{
    int ret1 = Add(20);
    int ret2 = Add(20,30);
    cout << ret1 << endl;
    cout << ret2 << endl;
    system("pause");
    return 0;
}

带缺省值的参数必须放在参数表的最后面，所以下面这种缺省参数是错误的写法

int Add(int a=10 , int b)
{
    return a + b;
}