名字空间

一 名字空间的引入：

  在C++中名称可以是变量 函数 结构体 类 及类的相关成员 使用第三方类库
  时 极有可能出现名称冲突 c++利用作用域的特性引入了名字空间的概念
  名字空间：名字空间是一种描述逻辑分组的机制 
            防止命名冲突 跨文件访问
注意：
名字空间 可以是全局的 可以是位于另一个名称空间中 不可以存在于代码块中

二 使用

1定义： 
    namespace A{
int I;
double d;
          void show();
    }
    namespace B{
int I
          float f;}
    A 中的I 与B 中的I 并不发生冲突

2 相同名字空间可以多次添加补充名字空间的内容
    namespace A{
   show(){
          …….
           }
    };
 非用户定义的名称空间存在于 全局命名空间

int I;
 使用: A::I = 0;
       B::I = 1;
       ::I = 2; //全局命名空间
      ：： 为作用域解析运算符 （域运算符）
 

三 using 指令
1 Using :为了避免每次都使用名字空间时都要其进行名字空间限定 
         可以使用using 对名字空间内的内容进行特定区域的声明
         using A::I; //using声明 std::cout
再次使用可以直接调用名称而无需增加空间限定

2 using :作为编译指令的使用 使对应名字空间内的所有内容可用 且使用时可
         以省略作用域解析运算符
         using namespace A ;


 注意事项： 1避免歧义 

    using A::I;
     using B:: I;
     I=1; //??哪一个？
           2 不要用using 声明相同名称的内容  using A::I ;int I;
           3 using 做编译指令时 名称空间为全局 如果局部于名称空间的
            名字相同 则局部覆盖名字空间内容 namespace {extern int i}
           4 局部名称会覆盖全局与using指令的名字空间内容 但可以用
             I（局部） ::I（全局） A：：I(名字空间)区分使用
           5 using声明比using编译安全 

             声明是指定具体内容 编译器发出指示 
             编译指令导入全部名字空间内容 可能发生冲突 覆盖时编译器
             不会发出警告

四 命名空间的嵌套
  
Namespace A{
int a;
    namespace B{
int b;
    }
}
访问： A：：B：： b =1;

未命名名字空间:内部链接特性 与static 修饰的内容特性相同
Namespace {
int a;
} cout<<a<<endl;
补充：
1 Iostream 相关函数 存放在std的名字空间内
Using 
Std::cout<<....

五 内联名字空间（c++11）

关键字 inline 
一种新的嵌套名字空间的使用方式
嵌套在名字空间的内联名字空间在使用时不需其名字空间进行限定使用
Inline namespace inspace {} 

#include<iostream>
using namespace std;
namespace A{
	int i;
	double d;
	void print(void){
		cout << "A::print" << endl;
	}
}
namespace B{
	int i = 1;
	double d = 1.1;
	void print(void);
}
namespace B{//声明与定义分离
	void print(void){
		cout << "B::print" << endl;
	}
}
namespace B{
	int j = 2;
	namespace b{
		int j = 1;
	}
}
int j = 3;
int main(){
	cout<< "A::i= " << A::i << " " << "A::d= " << A::d << endl;
	A::print();
	cout << "B::i= " << B::i << " " << "B::d= " << B::d << endl;
	B::print();
	cout << "B::j = " << B::j << endl;
	int j = 4;
	cout << j << endl;
	cout << ::j << endl;
	cout << B::j << endl;
	cout << B::b::j << endl;
	getchar();
	return 0;
}

#include<iostream>
#include<cstring>
#include"ex.h"
using namespace std;
namespace student {
	char name[10];
	int age = 100;
	double score;
}
namespace B {
	int age = 100;
}
namespace C {
	int a = 1;
}
namespace D {
	int a = 2;
}
using namespace C;
//using namespace student;
/*namespace{
extern int ex;
}
编译器在内部会为这个命名空间生成一个唯一的名字，而且还会为这个匿名的命名空间生成一条using指令。所以上面的代码在效果上等同于：

namespace __UNIQUE_NAME_ {

char c;

int i;

double d;

}

using namespace __UNIQUE_NAME_;
匿名的命名空间中定义的名字可以在定义该命名空间所在的作用域中可见，如果在文件的最外层作用域中定义匿名的命名空间，那么该匿名的命名空间中的名字必须与全局作用域中的名字不同
*/
namespace
{
	int noName = 250;
}
// noName = 500;//全局域的变量会与匿名空间的变量发生冲突
namespace X {
	int i = 0;
	int noName = 450;
	namespace {//不用加名称限定
		int noName = 350;
	}

	namespace XX {
		int j = 0;
	}
}


// 内联名字空间
namespace sqlHelper
{
	inline namespace helper1
	{
		void operation() {
			std::cout << "help1 woking...." << endl;
		}
	}
	namespace helper1 {//默认内联
		int i;
	}
	namespace helper2
	{
		void operation() {
			std::cout << "help2 working..." << endl;
		}
	}
}
int main() {
	//------------using student::X
	//	student::age = 1;
	using student::age;
	//	age = 1; 
	//	cout << "age = " << age << endl; 这样比较多次限定
	cout << "age = " << age << endl;
	//-----------using namespace X
	using namespace student;
	strcpy_s(name, "lilei");
	age = 20;
	score = 99.9;
	cout << name << ": " << age << ": " << score << endl;
	//----------注意事项
	int a = 0;
	//	using C::a; // 报错
	//using D::a;//报错  
	using namespace D;// 会报错 
	cout << a << endl;
	cout << "noName = " << noName << endl;
	cout << X::noName << " " << X::XX::j << " " << "  " << endl;
	cout << ex << endl;
	extern int ex1;
	extern int staticEx1;
	cout << ex1 << endl;
	//cout << staticEx1 << endl;//声明不报错 使用则报错
	//extern int noNameEx;//即名称的作用域被限制在当前文件中 
	//cout << noNameEx << endl;//声明不报错 使用则报错
	//using namespace ex;
	//extern int namespaceEx;
	cout << ex::namespaceEx << endl;

	sqlHelper::operation();
	sqlHelper::helper1::operation();
	sqlHelper::helper2::operation();
	getchar();
	return 0;
}