【C++】命名空间相关知识梳理

1.为何要有命名空间？

        在C语言中，变量/函数/类（C语言中是结构体）的名称都会在全局作用域中存在，可能会导致很多冲突。为此，C++提出了命名空间的概念，使用命名空间的目的是对标识符的名称进行本地化（也就是区分公用和私用，做隔离），以避免命名冲突或名字污染。

        一个C语言命名冲突的例子：

#include <stdio.h>
#include <stdlib.h>
int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决
int main()
{
printf("%d\n", rand);
return 0;
}
// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

上例中全局变量的名称和头文件中函数名称冲突，C语言只能通过改名的方式解决，于是C++做出了优化。

2.命名空间的定义

        首先，定义命名空间要使用命名空间的关键字namespace，然后像这样：

namespace kn
{
    // 命名空间中可以定义变量/函数/类型
    int rand = 10;
    int Add(int left, int right)
    {
    return left + right;
    }
    struct Node
    {
    struct Node* next;
    int val;
    };
}//注意这里没有“ ；”

 注意把命名空间和结构体定义区分，命名空间最后没有 “  ；”

2.1命名空间的性质

2.1.1命名空间可嵌套

//命名空间可以嵌套

namespace N1
{
    int a;
    int b;
    int Add(int left, int right)
    {
    return left + right;
    }
    namespace N2
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
        return left - right;
        }
    }
}

2.1.2同名命名空间会合并

//test.cpp
namespace N1
{
    int a;
    int b;
    int Add(int left, int right)
    {
    return left + right;
    }
    namespace N2
    {
        int c;
        int d;
        int Sub(int left, int right)
        {
        return left - right;
        }
    }
}
//同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个

// test.h
namespace N1
{
    int Mul(int left, int right)
    {
    return left * right;
    }
}

同一个工程中存在多个相同名称的命名空间时,编译器最后会把他们合成同一个命名空间中。
ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个。

2.1.3命名空间具有隔离作用的域

        先看如下例子：

#include <stdlib.h>
namespace kn
{
    int rand = 10;// 此时rand重定义的报错消失了，因为这个rand被隔离了起来
    int Add(int left, int right)
    {
    return left + right;
    }
    struct Node
    {
    struct Node* next;
    int val;
    };
}

int main()
{
   int ret = Add(1,2);//运行会报错，error C3861: “Add”: 找不到标识符
   return 0;
}

        这个代码运行时会出错，这是因为在编译时编译器会默认去局部域找函数名，再去全局域找，并不会去命名空间定义的命名空间域找。

        要点：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。

2.1.4命名空间隔离不改变内容的性质

        注意：在命名空间中定义的全局变量依然是全局变量，通过命名空间隔离不会改变对象的声明周期。

2.2命名空间的使用

        既然命名空间会隔离在局部域和全局域之外，那我们该如何使用命名空间里的内容呢？

2.2.1使用作用域限定符

namespace kn
{
    int rand = 10;
    int Add(int left, int right)
    {
    return left + right;
    }
    struct Node
    {
    struct Node* next;
    int val;
    };
}


int main()
{
   int ret = kn::Add(1,2);//使用作用域限定符限定域“kn”
   return 0;
}

若引用变量则同理，若命名空间嵌套，则先外层后里层，例如：

namespace out
{
    namespace inside
    {
        int rand = 10;
        int Add(int left, int right)
        {
            return left + right;
        }
        struct Node
        {
            struct Node* next;
            int val;
        };
    }
}

int main()
{
    int ret = out::inside::Add(1, 2);
    return 0;
}

注意：如果指定的作用域里没有对应的变量/函数名/类，会报错（编译器只会在指定的类里找）。

作用域限定符左端无作用域的特殊情形：

int Add(int left, int right)
{
    return left + right;
}
namespace out
{
    namespace inside
    {
        int rand = 10;
        int Add(int left, int right)
        {
            return left + right;
        }
        struct Node
        {
            struct Node* next;
            int val;
        };
    }
}

int main()
{
    int ret = ::Add(1, 2);//“：：”左端省略，编译器默认去全局中找Add，
                          //而全局中定义了Add，正常运行
    return 0;
}

以上情况不报错，因为“：：”左端不写作用域名称时，编译器默认只去全局作用域中查找。

namespace inside
{
        int rand = 10;
        int Add(int left, int right)
        {
            return left + right;
        }
        struct Node
        {
            struct Node* next;
            int val;
        };
}

int main()
{
    int a = 0;
    int ret = ::Add(1, 2);//此时全局没有定义Add，编译器默认也不去命名空间域里找
                          //报错，error C3861: “Add”: 找不到标识符
    return 0;
}

2.2.2展开命名空间

        还可以使用using namespace展开命名空间来使用：

namespace kn
{
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
}
using namespace kn;
int main()
{
    int a = 0;
    int ret = Add(1, 2);
    return 0;
}

        命名空间展开后和全局域一样变成公共区域，编译器会默认查找，所以在using namespace后，其中的内容不需要作用域限定符也可以直接使用。

        但是展开命名空间也会有不好的影响：

#include <stdlib.h>
namespace kn
{
    int rand = 10;
    int Add(int left, int right)
    {
        return left + right;
    }
    struct Node
    {
        struct Node* next;
        int val;
    };
}
using namespace kn;
int main()
{
    int a = 0;
    rand = 10;//报错，error C2872: “rand”: 不明确的符号
    return 0;
}

        展开后，命名冲突的问题又出现了，因为编译器默认先去局部查找，再去全局和展开的命名空间域找，因为全局域和展开的命名空间域优先级相同，使得rand这个名称产生了歧义，所以产生了错误。

        一般来说在大型项目中为了防止命名冲突，不推荐展开命名空间。

2.2.3展开单个命名空间成员

        除了将整个命名空间展开外，还可以只展开最常用的部分，例如：

namespace N
{
    int a;
    int b;
    int c;
}
using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    printf("%d\n",c);//c是没法使用的，因为此时命名空间只展开了b这一个成员
    return 0;
}