【C++】命名空间

#命名空间定义

namespace   +    自定义名字   +    {}       

namespace是关键字

namespace 名字
{
    //声明  定义


}//结尾无分号

能出现在全局作用域的声明、定义，就能出现在命名空间中。（包括命名空间和头文件）

namespace A
{
	int a = 2;
	namespace B
	{
		int b = a;//内层嵌套可以直接使用外层嵌套
        int a = A::a//内层嵌套会隐藏外层嵌套同名成员，此时需要用::来访问A
	}
    int c = B::b;//外侧嵌套不能直接使用内层嵌套
}

namespace C
{
#include<stdlib.h>   //一般不这么做
	int* a = (int*)malloc(100);
}

命名空间相当于作用域，在相同的命名空间使用相同的成员名会报错。

namespace A
{
	int b = 2;
	int b;//重定义
	int c;
}

#命名空间的使用

用   ：：  来访问命名空间中的成员。

使用方法：命名空间名字 +   ::   +  被访问成员名字

namespace A
{
	int a = 1;
	int b = 2;
	int c = 3;
}

namespace B
{
	int a = 4;
	int b = 5;
	int c = 6;
}
int main()
{
	cout << A::b << endl;//结果是2
	cout << B::b << endl;//结果是5
	return 0;
}

全局变量、函数在全局命名空间（也就是全局作用域）。因为全局空间没有名字，所以不用名字直接：：访问。

int a = 0;
void func()
{
	return;
}

int main()
{
	cout << ::a << endl;
	::func();

	return 0;
}

#命名空间可以不连续

相同名字的命名空间会被识别为同一个命名空间。

namespace A
{
	int a = 1;
	int b = 2;
	int c = 3;
}

namespace B
{
	int a = 4;
	int b = 5;
	int c = 6;
}

namespace A
{
	int d = 5;
	int a = 0;//上面的A已经有一个al，这里会报错重定义
}

int main()
{
	cout << A::d << endl;//结果是5


}

#命名空间可以分文件编写

#命名空间外定义成员

namespace C
{
	int a;
	void func();
}
int C::a = 0;
void C::func()
{
	return;
}

要在命名空间外定义成，必须保证成员定义的空间包含自己的声明所在的空间。

namespace C
{
	int a;
	void func();
}


void func11()
{
	void C::func()//这样定义是错的
	{
		return;
	};

	int C::a = 0;//错的

}

#内联命名空间

使用方法： inline  +  命名空间

内联命名空间的成员可以直接被外层空间使用（内联命名空间是嵌套空间）

inline namespace C
{
	int a = 0;
	int b = 1;
	int c = 2;
}
int main()
{
	cout << a << endl;

	return 0;
}

内联命名空间只需要在最开始的时候使用一次inline关键字就可以，后面无需再写inline关键字。

inline namespace C
{
	int a = 0;
	int b = 1;
	int c = 2;
}
namespace D
{
	int o=8;
}
namespace C
{
	int e = 9;
}

int main()
{
	cout << e << endl;

	return 0;
}

#未命名的命名空间

字面的意思，没有名字的命名空间，可以在一些作用域里直接使用。

namespace
{
	int a = 0;
	int b = 1;
	int d = 2;
}

int main()
{
	cout << d << endl;

	return 0;
}

#命名空间的别名

命名格式：namespace  +   自定义的名字   +     命名空间的名字

namespace A
{
	int a = 0;
	int b = 1;
	int d = c;
	namespace B
	{
		int a = 1;
		int b = 2;
	}
}

namespace C = A;
namespace D = C::B;

int main()
{
	cout << C::a << endl;//结果是0
	cout << D::a << endl;//结果是1
	return 0;
}

#using声明

使用方式：using   +    命名空间名字   +   命名空间成员

从suing声明的地方开始，直到作用域结束，suing声明的成员不再需要：：访问命名空间。

namespace A
{
	int a = 0;
	int b = 1;
	int d = 2;
	namespace B
	{
		int a = 1;
		int b = 2;
	}
}

int main()
{
	using A::a;
	using A::B::b;
	cout << a << endl;//结果是0
	cout << b << endl;//结果是2
	return 0;
}

#using指示

使用方法：using   +    namespace   +   命名空间名字

从suing声明的地方开始，直到作用域结束，suing指示的命名空间不再需要：：访问。

namespace A
{
	int a = 0;
	int b = 1;
	int d = 2;
	namespace B
	{
		int a = 1;
		int b = 2;
	}
}

int main()
{
	using namespace A;
	cout << a << endl;//结果是0
	cout << b << endl;//结果是1
	return 0;
}