命名空间的定义与使用（转）

1. 命名空间的定义：由关键字 namespace后边接着命名空间名字，之后接一对花括弧括住的一块声明和定义；

 

//17.2.A.h   头文件定义命名空间 primer_17_2  

 

//17.2.A.h   头文件定义命名空间 primer_17_2
 
namespace primer_17_2
{
  //定义成员类A
  class A
  {
    public:
      int getA(); //成员函数，定义在命名空间的定义文件中，并且在命名空间内部定义；
      int getB(); //成员函数，定义在命名空间的定义文件中，但是，它是在命名空间外部定义的，请查看下边的 17.2.A.cpp 定义文件；
      int fun() { return 0; } //成员函数及其实现体，在类内部定义，也就是在命名空间的头文件中定义；
      friend A operator+(const A &lhs, const A &rhs); //将操作符函数声明为友元函数，因为该函数被定义成了非成员函数；
    private:
      int v;
  };
  　　A operator+(const A &lhs, const A &rhs); //为命名空间primer_17_2声明一个加操作符成员，必须在命名空间头文件以外定义，在命名空间实现文件中定义时：既可以在命名空间内部定义也可以在外部定义，外部定义时必须指定命名空间限定符；在其他文件中定义时：必须指定命名空间限定符，以指明函数属于哪个命名空间；
  　　char get(); //为命名空间primer_17_2声明一个普通成员，方法同加操作符，本例中，该函数定义在了其他文件中，请看文件：17.2.C.cpp；
  　　const char ch1 = 'a';   //ok  为命名空间primer_17_2定义一个字符常量并初始化，常量必须设置初始值；
  　　static char ch2 = 'b';   //ok  为命名空间primer_17_2定义一个静态字符常量，并设置初始值，在使用的程序中可以修改；
  　　static char ch3;// = 'c';    //ok  为命名空间primer_17_2定义一个字符常量，不设置初始值，在使用的程序中可以修改；
  　　//static const char ch4;    //error, 常量必须设置初始值；
  　　static const char ch4 = 'd';    //ok  静态的常量，设置了初始值；
  　　extern char ch5;    //声明字符变量ch5，在使用的程序中进行定义，如：char primer_17_2::ch5，或 char primer_17_2::ch5 = 'e'，必须在extern声明后，再在命名空间实现文件中定义该变量；
  　　extern int n;    //声明定义方法同上；
 
} //; 这里不需要以分号结尾

　　

在花括弧中可以出现 能够全局作用域中出现的任意声明：类，变量（以及他们的初始化），函数（以及他们的定义），模板以及其他的命名空间

2. 命名空间成员的定义：

(a)  命名空间中，类的成员函数可以在命名空间的类的内部定义，也可以在命名空间的实现文件中定义；如：上述的类成员函数int getA()在命名空间的实现文件中定义，而成员函数 int fun();则在类内部定义，自动成为内联函数；

(b)   命名空间的直接成员，必须在头文件声明，在实现文件中定义，如：上述 char get()与 加操作符函数 定义在命名空间的实现文件中；

 

//17.2.A.cpp
 
#include "17.2.A.h"
namespace primer_17_2
{
  int A::getA()  //类A的成员函数，在命名空间实现文件中定义，并且在命名空间内部定义；
  {
    return v;
  }
 
  A operator+(const A &lhs, const A &rhs) //命名空间的直接成员函数，在命名空间实现文件中定义，并且在命名空间内部定义；
  {
    A a;
    a.v = lhs.v + rhs.v;
    return a;
  }
 
  /*char get() //注释掉了，为了说明在其他文件中如何定义命名空间的直接成员，查看 17.2.C.cpp
  {
    return 'm';
  }
  */
 
  int n = 0; //注意变量n的定义，首先在头文件中extern声明，然后在命名空间实现文件中进行定义，赋值或不赋值都可以；
  char ch5 = 'e'; //声明与定义方法同上；
 }
 
int primer_17_2::A::getB() //类A的成员函数，在命名空间实现文件中定义，并且在命名空间外部定义；
{
  return 100;
}
 
char primer_17_2::get(char c)  //命名空间的直接成员函数，在命名空间实现文件中定义，并且在命名空间外部定义；
{
  return c;
}
 
// 17.2.C.cpp，观察primer_17_2 的直接成员 char get();的定义：
 
#include "17.2.C.h"
#include "17.2.A.h"
namespace AA
{
  int getAA()
  {
    return -1;
  }
 
  //error, primer_17_2的 成员get在这里定义是非法的，这里的作用域属于命名空间AA；
  /*
  char primer_17_2::get()
  {
    return 'z';
  }
  */
}
 
//ok，在这里定义必须指定primer_17_2限定符；
char primer_17_2::get()
{
  return 'z';
}

　　

3. 命名空间成员定义总结：

（a）命名空间直接成员函数：在命名空间头文件以外定义时，既可以在命名空间实现文件中定义，也可以在其他文件中定义：

          (a.1)   在命名空间实现文件定义时：既可以在命名空间内部(花括弧以内)定义也可以在外部(花括弧以外)定义，外部定义时必须指定命名空间限定符；

          (a.2)   在其他文件中定义时：必须指定命名空间限定符，以指明函数属于哪个命名空间；

（b）类类型及模板类型：其成员函数可以在类内部定义，也可以在命名空间的实现文件定义，这时可以在内部也可以在外部，在其他文件中定义时须指定命名空间限定符；

（c）非const以及非static直接变量，必须以extern进行声明，然后在使用该变量的地方进行定义，如上述例子中的变量ch5与n的声明与定义；

（d）命名空间可以不连续定义，即在多个文件中进行成员的声明和定义，这些成员的声明和定义是累积的，共同组成同一个命名空间；

4. 命名空间的使用：

#include <iostream>
#include "17.2.A.h"
 
using namespace std;
using namespace primer_17_2;
 
int main()
{
  A a;
  A b;
  A ab = a + b;
  cout << "ab.v:" << ab.getA() << endl;
  cout << "primer_17_2::get():" << get() << endl;
  cout << "primer_17_2::ch1:" << ch1 << endl;
  ch2 = 'b'; //primer_17_2::ch2
  cout << "primer_17_2::ch2:" << ch2 << endl;
  ch3 = 'c';
  cout << "primer_17_2::ch3:" << ch3 << endl;
  cout << "primer_17_2::ch4:" << ch4 << endl;
  cout << "primer_17_2::ch5:" << ch5 << endl;
  cout << "primer_17_2::n:" << n << endl;
  return 0;
}

　　

运行结果：

ab.v:100
primer_17_2::get():z
primer_17_2::ch1:a
primer_17_2::ch2:b
primer_17_2::ch3:c
primer_17_2::ch4:d
primer_17_2::ch5:e
primer_17_2::n:0

https://blog.csdn.net/ljq32/article/details/7937742#