C++命名空间详解

1.命名空间的定义

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

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

运行结果：

定义的变量rand和rand函数冲突，不知道是变量还函数。

2.命名空间的使用

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

命名空间的调用

#include<stdio.h>
#include<iostream>
namespace bite
{
	//......
}

命名空间的使用示例：

#include <iostream>
#include<stdio.h>
int x = 0;
//命名空间可以定义变量，函数，结构体，
namespace bite1
{
   int x = 5;
}
namespace bite1      //同名的命名空间编译器会把他们合并起来
{
    int y = 4;
}
namespace bite2
{
    int z = 6;
}
//编译器搜索原则：先局部域搜索，再去全局域搜索，前面都找不到则报错
int main()
{
    //C风格代码
    int x = 1;
    std::cout << "Hello World!\n";
    printf("x = %d\n", x);                       //全局、局部同一变量，局部优先
    printf("x = %d\n", ::x);                     //打印全局可以用::域作用限定符
    printf("bite1 的 x = %d\n", bite1::x);       //访问命名空间域bite1中的变量x
    printf("bite1 的 y = %d\n", bite1::y);       //访问命名空间域bite1中的变量y
    printf("bite2 的 z = %d\n", bite2::z);       //访问命名空间域bite2
    //printf("bite2 的 x = %d\n", bite2::y);     //访问命名空间域bite2中不存在的变量则会报错
}

运行结果：

使用命名空间时，编译器搜索原则：先局部域搜索，再去全局域搜索，前面都找不到则报错。

指定域和不指定域的命名空间调用区别
::域作用限定符
编译器搜索原则：
不指定域：1、先在当前局部域 2、再从全局域找
指定域： 3、如果指定了，直接去指定域搜索

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
namespace bite1                                  //命名空间可以定义变量，函数，结构体，
{
    int rand = 6;                                //变量
    int x = 9;
    int Add(int right, int left)                 //函数
    {
        return right + left;
    }
    struct Node                                  //结构体
    {
        struct Node* next;
        int val;
    };
}
namespace bite2
{
    int y = 2;
}

int main()
{
    printf("bite1::x = %d\n", bite1::x);
    printf("bit2::y = %d\n", bite2::y);
    printf("bite1::rand = %d\n", bite1::rand);
    printf("rand 的地址 = %p\n", rand);
    printf("bite1::Add(3,4) = %d\n", bite1::Add(3,4));
    return 0;
}

运行结果：

3.命名空间的使用有三种方式：

1. 加命名空间名称及作用域限定符
2. 使用using将命名空间中某个成员引入
3. 使用using namespace 命名空间名称引入

1. 加命名空间名称及作用域限定符:

#include<iostream>
#include<iostream>
namespace N
{
	int a = 1;
}
int main()
{
	 printf("%d\n", N::a); //1. 加命名空间名称及作用域限定符
	return 0;
}

2. 使用using将命名空间中某个成员引入

#include<iostream>
#include<iostream>
namespace N
{
	int a = 1;
	int b = 1;
}
using N::b;

int main()
{
	 printf("%d\n", N::a); //1. 加命名空间名称及作用域限定符
	 printf("%d\n", b);
	return 0;
}

3. 使用using namespace 命名空间名称引入**

#include<iostream>
using namespace std;
namespace N1
{
    int a = 5, b = 8;
    int Add(int left, int right)
    {
        return left + right;
    }
}
namespace N2                                 //命名空间嵌套
{
    int x = 6, y = 9;
    int Sub(int left, int right)
    {
        return left - right;
    }
    namespace N3
    {
        int vx = 8, vy = 9;
        int Mul(int left, int right)
        {
            return left * right;
        }
    }
}

int Q = 8;                 //1.加命名空间名称及作用域限定符
using N1::a;               //2.使用using将命名空间中某个成员引入
using namespace N1;        //3.使用using namespace 命名空间名称引入

int main()
{
    cout << "::Q = " << ::Q << endl;                     //1.作用域限定符::访问全局变量
    cout << "a = " << a << endl;                         //2.使用using将命名空间中某个成员引入
    cout << "N1::a = " << N1::a << endl;                 //3.使用using namespace 命名空间名称引入

    cout << "N1::a = " << N1::a << endl;
    cout << "N1::b = " << N1::b << endl;
    cout << "N1::Add(3, 6) = " << N1::Add(3, 6) << endl;

    cout << "N2::x = " << N2::x << endl;
    cout << "N2::y = " << N2::y << endl;
    cout << "N2::Sub(6, 3) = " << N2::Sub(6, 3) << endl;

    cout << "N2::N3::vx = " << N2::N3::vx << endl;
    cout << "N2::N3::vy = " << N2::N3::vy << endl;
    cout << "N2::N3::Mul(8,9) = " << N2::N3::Mul(8, 9) << endl;
    return 0;
}

运行结果：

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/ea5a32c2865449aab62c029376923954.png