C++命名空间的解释 【转】

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突。在C++中，变量、函数和类都是大量存在的。如果没有命名空间，这些变量、函数、类的名称将都存在于全局命名空间中，会导致很多冲突。比如，如果我们在自己的程序中定义了一个函数toupper()，这将重写标准库中的toupper()函 数，这是因为这两个函数都是位于全局命名空间中的。命名冲突还会发生在一个程序中使用两个或者更多的第三方库的情况中。此时，很有可能，其中一个库中的名 称和另外一个库中的名称是相同的，这样就冲突了。这种情况会经常发生在类的名称上。比如，我们在自己的程序中定义了一个Stack类，而我们程序中使用的某个库中也可能定义了一个同名的类，此时名称就冲突了。

Namespace 关键字的出现就是针对这种问题的。由于这种机制对于声明于其中的名称都进行了本地化，就使得相同的名称可以在不同的上下文中使用，而不会引起名称的冲突。或许命名空间最大的受益者就是C++中的标准库了。在命名空间出现之前，整个C++库都是定义在全局命名空间中的（这当然也是唯一的命名空间）。引入命名空间后，C++库就被定义到自己的名称空间中了，称之为std。这样就减少了名称冲突的可能性。我们也可以在自己的程序中创建自己的命名空间，这样可以对我们认为可能导致冲突的名称进行本地化。这点在我们创建类或者是函数库的时候是特别重要的。

命名空间基础

namespace 关键字使得我们可以通过创建作用范围来对全局命名空间进行分隔。本质上来讲，一个命名空间就定义了一个范围。定义命名空间的基本形式如下：

namespace 名称{//声明}

在命名空间中定义的任何东西都局限于该命名空间内。

下面就是一个命名空间的例子，其中对一个实现简单递减计数器的类进行了本地化。在该命名空间中定义了计数器类用来实现计数；其中的upperbound和lowerbound用来表示计数器的上界和下界。

 

演示命名空间

 

  1. namespace CounterNameSpace
  2. {
  4.     int upperbound;
  5.     int lowerbound;
  7.     class counter
  8.     {
  10.         int count;
  11.    public:
  12.      counter(int n)
  13.      {
  15.             if ( n <= upperbound ){
  16.                 count = n;
  17.             } else  {
  18.                 count = upperbound;
  19.             }
  20.       }
  21.     void reset(int n)
  22.      {
  23.        if ( n < upperbound )
  24.             {
  25.                 count = n;
  26.             }
  27.         }
  28.      int run() {
  29.       if ( count > lowerbound)
  30.        {
  31.                 return count--;
  32.        } else {
  33.                 return lowerbound;
  34.        }
  35.       }
  36.     };
  37. }

其中的upperbound，lowerbound和类counter都是有命名空间CounterNameSpace定义范围的组成部分。

在命名空间中声明的标识符是可以被直接引用的，不需要任何的命名空间的修饰符。例如，在CounterNameSapce命名空间中，run()函数中就可以直接在语句中引用lowerbound：

点击(此处)折叠或打开

  1. if ( count > lowerbound)
  3. {
  5. return count--;
  7. }

然而，既然命名空间定义了一个范围，那么我们在命名空间之外就需要使用范围解析运算符来引用命名空间中的对象。例如，在命名空间CounterNameSpace定义的范围之外给upperbound赋值为10，就必须这样写：

CounterNameSpace::upperbound = 10;

或者在CounterNameSpace定义的范围之外想要声明一个counter类的对象就必须这样写：

CounterNameSpace::counter obj;

一般来讲，在命名空间之外想要访问命名空间内部的成员需要在成员前面加上命名空间和范围解析运算符。

下面的程序演示了如何使用CounterNameSpace这个命名空间：

 

演示命名空间

 

  1. #include <iostream>
  2. using namespace std;
  3. namespace CounterNameSpace
  4. {
  5.     int upperbound;
  6.     int lowerbound;
  8.     class counter
  9.     {
  10.         int count;
  11.     public:
  12.         counter(int n)
  13.         {
  14.             if ( n <= upperbound )
  15.             {
  16.                 count = n;
  17.             } else
  18.             {
  19.                 count = upperbound;
  20.             }
  21.         }
  22.         void reset(int n)
  23.         {
  24.             if ( n < upperbound )
  25.             {
  26.                 count = n;
  27.             }
  28.         }
  29.         int run()
  30.         {
  31.           if ( count > lowerbound)
  32.             {
  33.                 return count--;
  34.             }
  35.             else
  36.                 return lowerbound;
  37.         }
  38.     };
  39. }
  41. int main()
  42. {
  43.  CounterNameSpace::upperbound = 100;
  44.  CounterNameSpace::lowerbound = 0;
  45.  CounterNameSpace::counter ob1(10);
  46.   int i;
  47.   do {
  48.    i = ob1.run();        
  49.    cout << i << " ";
  50.  } while (i > CounterNameSpace::lowerbound);
  51.  cout << endl;
  52.  CounterNameSpace::counter ob2(20);
  53. do {
  54.     i = ob2.run();
  55.     cout << i << " ";
  56.     } while (i > CounterNameSpace::lowerbound);
  58.     cout << endl;
  59.     ob2.reset(100);
  60.     do
  61.     {  i = ob2.run();
  62.         cout << i << " ";
  64.     } while (i > CounterNameSpace::lowerbound);
  65.     cout << endl;
  66.     return 0;
  67. }

请注意：counter类以及upperbound和lowerbound的引用都是在前面加上了CounterNameSpace修饰符。但是，一旦声明了counter类型的对象，就没有必须在对该对象的任何成员使用这种修饰符了。因此ob1.run()是可以被直接调用的。其中的命名空间是可以被解析的。

相同的空间名称是可以被多次声明的,这种声明向相互补充的。这就使得命名空间可以被分割到几个文件中甚至是同一个文件的不同地方中。例如：

      

点击(此处)折叠或打开

  1. namespace NS
  3. {
  5. int i;
  7. }
  9.  
  11. //...
  14. namespace NS
  16. {
  18.     int j;
  20. }

 

其中命名空间NS被分割成两部分，但是两部分的内容却是位于同一命名空间中的。也就是NS。最后一点：命名空间是可以嵌套的。也就是说可以在一个命名空间内部声明另外的命名空间。

using关键字

如果在程序中需要多次引用某个命名空间的成员，那么按照之前的说法，我们每次都要使用范围解析符来指定该命名空间，这是一件很麻烦的事情。为了解决这个问题，人们引入了using关键字。using语句通常有两种使用方式：

using namespace 命名空间名称;

using 命名空间名称::成员；

第一种形式中的命名空间名称就是我们要访问的命名空间。该命名空间中的所有成员都会被引入到当前范围中。也就是说，他们都变成当前命名空间的一部分了，使用的时候不再需要使用范围限定符了。第二种形式只是让指定的命名空间中的指定成员在当前范围中变为可见。我们用前面的CounterNameSpace来举例，下面的using语句和赋值语句都是有效的：

using CounterNameSpace::lowerbound; //只有lowerbound当前是可见的

lowerbound = 10; //这样写是合法的，因为lowerbound成员当前是可见的

using CounterNameSpace; //所有CounterNameSpace空间的成员当前都是可见的

upperbound = 100; //这样写是合法的，因为所有的CounterNameSpace成员目前都是可见的

下面是我们对之前的程序进行修改的结果:

使用using

 

  1. #include <iostream>
  3.  
  5. using namespace std;
  7.  
  9. namespace CounterNameSpace
  11. {
  13.     int upperbound;
  15.     int lowerbound;
  17.     class counter
  19.     {
  21.         int count;
  23.     public:
  25.         counter(int n)
  27.         {
  29.             if ( n < upperbound)
  31.             {
  33.                 count = n;
  35.             }
  37.             else
  39.             {
  41.                 count = upperbound;
  43.             }
  45.         }
  47.  
  49.         void reset( int n )
  51.         {
  53.             if ( n <= upperbound )
  55.             {
  57.                 count = n;
  59.             }
  61.         }
  63.  
  65.         int run()
  67.         {
  69.             if ( count > lowerbound )
  71.             {
  73.                 return count--;
  75.             }
  1.             else
  2.             {
  3.                 return lowerbound;
  4.             }
  5.         }
  6.     }; 
  7. }
  8. int main()
  10. {
  12.     //这里只是用CounterNameSpace中的upperbound
  14.     using CounterNameSpace::upperbound;
  16.  
  18.     //此时对upperbound的访问就不需要使用范围限定符了
  20.     upperbound = 100;
  22.     //但是使用lowerbound的时候，还是需要使用范围限定符的
  24.     CounterNameSpace::lowerbound = 0;
  26.     CounterNameSpace::counter ob1(10);
  28.     int i;
  30.  
  32.     do
  34.     {
  36.         i = ob1.run();
  38.         cout << i << " ";
  40.     }while( i > CounterNameSpace::lowerbound);
  42.     cout << endl;
  44.  
  46.     //下面我们将使用整个CounterNameSpace的命名空间
  48.     using namespace CounterNameSpace;
  50.     counter ob2(20);
  52.     do
  54.     {
  56.         i = ob2.run();
  58.         cout << i << " ";
  60.     }while( i > CounterNameSpace::lowerbound);
  62.     cout << endl;
  64.  
  66.     ob2.reset(100);
  68.     lowerbound = 90;
  70.     do
  72.     {
  74.         i = ob2.run();
  76.         cout << i << " ";
  78.     }while( i > lowerbound);
  80.  
  82.     return 0;
  84. }
  86. 上面的程序还为我们演示了重要的一点：当我们用using引入一个命名空间的时候，如果之前有引用过别的命名空间（或者同一个命名空间），则不会覆盖掉对之前的引入，而是对之前引入内容的补充。也就是说，到最后，上述程序中的std和CounterNameSpace这两个命名空间都变成全局空间了。
  88. 没有名称的命名空间
  90. 有一种特殊的命名空间，叫做未命名的命名空间。这种没有名称的命名空间使得我们可以创建在一个文件范围里可用的命名空间。其一般形式如下：
  92. namespace
  94. {
  96.     //声明
  98. }

 

我 们可以使用这种没有名称的命名空间创建只有在声明他的文件中才可见的标识符。也即是说，只有在声明这个命名空间的文件中，它的成员才是可见的，它的成员才 是可以被直接使用的，不需要命名空间名称来修饰。对于其他文件，该命名空间是不可见的。我们在前面曾经提到过，把全局名称的作用域限制在声明他的文件的一 种方式就是把它声明为静态的。尽管C++是支持静态全局声明的，但是更好的方式就是使用这里的未命名的命名空间。

std命名空间

标准C++把自己的整个库定义在std命名空间中。这就是本书的大部分程序都有下面代码的原因：

using namespace std;

这样写是为了把std命名空间的成员都引入到当前的命名空间中，以便我们可以直接使用其中的函数和类，而不用每次都写上std::。

当然，我们是可以显示地在每次使用其中成员的时候都指定std::，只要我们喜欢。例如，我们可以显示地采用如下语句指定cout：

std::cout << “显示使用std::来指定cout”;

如果我们的程序中只是少量地使用了std命名空间中的成员，或者是引入std命名空间可能导致命名空间的冲突的话，我们就没有必要使用using namespace std;了。然而，如果在程序中我们要多次使用std命名空间的成员，则采用using namespace std;的方式把std命名空间的成员都引入到当前命名空间中会显得方便很多，而不用每次都单独在使用的时候显示指定

 

转载地址：http://blog.renren.com/share/730973714/7874424429

posted @ 2017-02-18 15:54  nullxjx  阅读(233)  评论(0)  编辑  收藏  举报