C++ namespace

一、什么是 namespace

1.1 C语言标识符作用域的缺陷

 在C语言中因为项目需要会定义各种全局变量、函数等，我们也会调用C语言标准库提供给我们的各种函数，这将会导致我们变量名、函数名与标准库中的发生命名冲突。

#include <stdio.h>
#include <stdlib.h>

int rand = 10; // 错误，与库函数rand命名冲突

int main()
{
	printf("%d\n", rand);  
}

1.2 namespace作用

 在C++中通过namespace来防止命名冲突，namespace相当一件隐身衣，在namespace中的变量、函数、类在namespace外面是看不到，访问不到的，相当于不存在，所以也就不会发生命名冲突。即一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

二、namespace的定义

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

namespace kxl // kxl 为空间名字
{
	int rand = 10;
	
	int sum(int x,int y)
	{
		return x+y;
	}
	
	struct Person
	{
		char name[10];
		int age;
	};
}

2.1 命名空间可以嵌套定义

namespace kxl // kxl 为空间名字
{
	int rand = 10;
	
	namespace kdl
	{
		int x = 0;
		int rand = 20;
	}
}

小技巧

命名空间嵌套层次太多时，使用里面的成员会很麻烦，可以对嵌套的命名空间取别名，这样使用起来会更加方便

#include <iostream>

namespace kxl // kxl 为空间名字
{
	int rand = 10;
	
	namespace kdl
	{
		int x = 0;
		int rand = 20;
		
		namespace kzl
		{
			int rand = 30;
			int y = 5;
		}
	}
}

namespace alias_kzl = kxl::kdl::kzl; // 别名

int main()
{
	std::cout<< alias_kzl::y << std::endl;
	
	return 0;
}

2.2 可定义重复的命名空间

在一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间，但相同命名空间中的变量、函数、类不能重复定义

namespace kxl // kxl 为空间名字
{
	int rand = 10;
}

namespace kxl // kxl 为空间名字
{
	// int rand = 20;  错误，相同命名空间变量名相同，编译器不知道合并哪一个rand
	int x = 20;
}

最终编译器合并为

namespace kxl // kxl 为空间名字
{
	int rand = 10;
	int x = 20;
}

三、namespace使用

3.1 命名空间名称+作用域限定符使用

语法： 空间名称::标识符名
相当于告诉编译器去哪一个命名空间中找哪一个对象

namespace kxl // kxl 为空间名字
{
	int rand = 10;
	int x = 0;
	int y = 1;
	
	namespace kdl
	{
		int x = 20; 
		int z = 100;
	} 
}

int main()
{
	printf("%d\n", kxl::rand); // kxl 为命名空间名称，:: 为作用域限定符， rand 为变量名
	printf("%d\n", kxl::kdl::x); // 访问kxl命名空间中的kdl里面的x变量
	return 0;
}

3.2 using将命名空间中成员引入

如果空间中某个对象经常使用，用3.1的方法比较繁琐，可以使用using关键字将空间中某个对象引入，即这个对象不隐身了，作用域为全局作用域
语法： using 空间名称::标识符名;

namespace kxl // kxl 为空间名字
{
	int rand = 10;
	int x = 0;
	int y = 1;
}

using kxl::x;
// using kxl::rand;  不要将rand这样引入，否则rand和库函数rand发生命名冲突
int main()
{
	printf("%d\n",x);
	return 0;
}

3.3 使用using namespace将整个空间成员引入

使用using namespace将整个空间成员引入，即隐身衣失效了，空间中所有对象的作用域都是全局作用域，可以直接访问，但是与C++中引入命名空间初衷相矛盾，一般不建议这样用

语法：using namespce 空间名称;

namespace kxl // kxl 为空间名字
{
	int x = 0;
	int y = 1;
}

using namespace kxl;

int main()
{
	printf("%d\n", x); // x 相当于正常定义的全局变量，可以直接访问
	printf("%d\n", y);
	return 0;
}

四、C++ 11 ~ C++ 20

4.1 C++ 11 内联命名空间

内联命名空间（Inline Namespace）是 C++11 中的一个特性，它允许在命名空间中嵌套另一个命名空间，并且将其内容直接导出到外部命名空间中，即内联命名空间的成员会被视为父命名空间的成员。

语法： inline 空间名

/*
可以将内联命名空间用作版本控制机制，以管理对库的公共接口的更改。 例如，可以创建单个父命名空间，并将接口的每个版本封装到嵌套在父命名空间内的其自己的命名空间中。 保留最新或首选的版本的命名空间限定为内联，并因此以父命名空间的直接成员的形式公开。
*/
namespace Test
{
    namespace v1
    {
        void Func()
        {
            std::cout << "v1 version" << std::endl;
        }
    }

    inline namespace v2 // v2 
    {
        void Func()
        {
            std::cout << "v2 version" << std::endl;
        }
    }
}


Test::v1::Func(); // 输出: v1 version 
Test::Func(); // 输出: v2 version 

4.2 C++ 17 嵌套命名空间简洁写法

C++17 允许使用简洁写法描述嵌套的命名空间，可以更清晰地表示出命名空间之间的逻辑关系。

namespace A::B::C // C++ 17
{
    void Fun()
    {
        std::cout << "Test()" << std::endl;
    }
}

上面代码等同于:
namespace A
{
    namespace B
    {
        namespace C
        {
            void Fun()
            {
                std::cout << "Test()" << std::endl;
            }
        }
    }
}

4.3 C++ 20

C++ 20支持简洁定义内联命名空间

namespace A::inline B::C // C++ 20支持，C++ 17不支持
{
    void Fun()
    {
        std::cout << "Test()" << std::endl;
    }
}

上面代码等同于:
namespace A
{
    inline namespace B
    {
        namespace C
        {
            void Fun()
            {
                std::cout << "Test()" << std::endl;
            }
        }
    }
}