《C++ primer》学习笔记之二十三： namespace的定义和使用

 namespace的定义和使用：
 1. //定义一个namespace common:
  //in common.h  
  namespace common
  {
   void fOfCommon(); //声明函数，但不定义
   void gOfCommon(); //声明函数
  }
  
  //in common.cpp
  namespace common
  {
   void fOfCommon(){ cout << "fOfCommon()" };   //定义函数fOfCommon，在common.h中有先声明
   void f2OfCommon(){ cout << "f2OfCommon()" };   //定义函数f2OfCommon，在common.h中没有声明，这个会有问题，因为外部无法访问这个函数
  }
  
  void common::gOfCommon(){ cout << "gOfCommon()" }; //定义函数gOfCommon
  void common::g2OfCommon(){ cout << "g2OfCommon()" }; //error:hOfCommon不是common的成员。
                //要么像gOfCommon一样先在namespace中声明，然后在外部定义
                //要么像f2OfCommon，直接在namespace中定义
  
  namespace只提供了"名字访问"的一种策略，它不改变在它内部定义的变量/函数的属性，  
  "global scope"实际是一个顶层的namespace，其它namespace都在它下面嵌套定义。与global scope一样：
   1. namespace内的函数/常量在头文件中声明，而定义放在.cpp文件中。声明和定义时，都要使用namespace关键字。
   2. 可以在global scope中定义的标识符，都可以在namespace中定义
   4. namespace中的函数/变量也遵守 “先定义（或声明），后调用” 的规则，
    一个namespace可以出现多次定义，新的定义将以增量的方式加到该namespace global中
   3. 作为global scope的小弟，namespace必须在另外一个namespace中定义，最外层的namespace即为global scope
    namespace不能在一个fuction中定义，
       也不能在一个class内定义。class实际也起到了namespace的作用，不知为何不可以？可能是这样做无意义。
 2. //访问namespace中的成员
  //test.cpp（接1中的代码）
  #include "common.h"  //记得写这句话
  void fOfGlobal(){ common::fOfCommon(); }  //用完整范围修饰  
  void fOfCommon(){ cout << "::fOfCommon()"; } //注意：它与common::fOfCommon同名
  
  void gOfGlobal()
  {
   fOfCommon();       //ok. 调用::fOfCommon
   gOfCommon();       //error: 找不到gOfCommon。它不在global scope中定义
      
   using common::gOfCommon;    //这句话将gOfCommon的可见范围提到了global scope   
   gOfCommon();       //像访问global function一样访问gOfCommon
   f2OfCommon();       //error：f2OfCommon的声明或定义并没有出现在本调用之前，注意它没在common.h中先声明
  }
  
  namespace co = common;      //为namespace重命名
    
  //两种错误的用法：
  using common;        //using后接具体的标识符，而common为一个namespace
  using namespace common::fOfCommon;   //using namespace后接namespace.
  using common::gOfCommon();     //不能指定函数原形
    
  int main()
  {
   using namespace co;      //将namespace内的所有成员的可见范围都提到了global scope
   fOfCommon();       //error:
             //不知道调用的是::fOfCommon还是common::fOfCommon
      
   using common::fOfCommon;
   fOfCommon();       //ok.上一句using把fOfCommon指定为common范围
   
   ::fOfCommon();       //ok:有scope修饰，直接到global scope找   
   common::fOfCommon();     //ok.有scope修饰，直接到common scope找   
  }
  
  可以这样说：标识符都是有scope修饰的，默认是global scope。只在修饰的scope中查找该标识符。
  当使用using namespace common后，则默认的scope增加namespace scope（每个scope修饰总是从global scope开始），
  比如:
   using namespace common;
   using namespace std; //不会到common中去找std，而只会在global scope中找std
   
  注意：1. 不会递归查找，即不会到scope内嵌套的namespace中找。
     2. using namespace common; 是条语句，可以出现在变量可以定义的位置。
       它的作用范围和变量的可见范围一样，从出现开始，到块结束。
     3. scope操作符'::'的优先级最高，标识符可以单独使用的地方，scope修饰加上标识符就可以使用。
 
 3. unnamed namespace: 即没有名字的namespace。该namespace在整个文件中都可见，且引用其内的成员不需要指定namespace名：
  //test.cpp
  namespace{      //unnamed namespace
   namespace{           //unnamed space
    void print(char *s){ cout << s << endl; };  
   }
   void sayHello(){ print("Unnamed."); };    //直接调用print
  }
  
  namespace T{
   void sayHelloT(){ print("T."); };    //直接调用print
  }
  
  int main()
  {
   sayHello();  //直接调用sayHello
   T::sayHelloT();
  } 
  
  unnamed namespace的用处是使函数本地可见，其它文件无法引用。相当于c中用static修饰函数