c 名称作用域-凯发app官方网站

=====================================================================================================
总则：namespace是命名空间，可以防止多个cpp文件有重复定义成员(变量，函数，类等)；
      using则纯粹是为了方便访问命名空间成员，避免视觉污染。
=====================================================================================================

1.命名空间有什么作用？如何定义命名空间？如何使命名空间生效？

      命名空间本质上只有一个作用：在每个.c文件周围构筑一道屏障,使得每个.c变量等生效空间
  局限于当前.c文件中。命名空间顺便的作用:简化书写。
  命名空间定义方式：
     a. namespace 空间名
        {
            常量、变量、函数、类等名字;
        }
     b. namespace
        {
            常量、变量、函数、类等名字;
        }

    命名空间的成员，是在命名空间定义中的花括号内声明了的名称。可以在命名空间的定义内，定义命名空间的
    成员（内部定义）。也可以只在命名空间的定义内声明成员，而在命名空间的定义之外，定义命名空间的
    成员（外部定义）。

   命名空间生效有下面两种方式:
        using 声明：using namespace 空间名
        using 指令：using std::cout

    也就是说如果定义了命名空间，但是未使用，还是无效的。
    必须用using关键字导入名字到特定的编译单元中（单个cpp文件）。

=====================================================================================================
2.  命名空间设置的位置？
    命名空间放在cpp文件的 开始的所有 include <> 包含文件之后。
    命名空间不能放在头文件里面的原因： 头文件被很多文件包含，如果放在头文件中，被两个文件同时包含时，
 就可能发生命名冲突。
    命名空间不能放在 include<>之前原因:可能你需要类还没包含进来，你命名空间无的放矢。

=====================================================================================================

在c 中，名称（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免，在大规模程序的设计中，以及在程序员使用各种各

样的c 库时，这些标识符的命名发生冲突，标准c 引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。 
 

mfc中并没有使用命名空间，但是在.net框架、mc 和c /cli中，都大量使用了命名空间。

1）作用域与命名空间
l         相关概念

与命名空间相关的概念有：

n       声明域（declaration region）—— 声明标识符的区域。如在函数外面声明的全局变量，它的声明

域为声明所在的文件。在函数内声明的局部变量，它的声明域为声明所在的代码块（例如整个函数体或整个复合语句）。

n       潜在作用域（potential scope）—— 从声明点开始，到声明域的末尾的区域。因为c 采用的是先

声明后使用的原则，所以在声明点之前的声明域中，标识符是不能用的。即，标识符的潜在作用域，一般会小于其声明域。

n       作用域（scope）—— 标识符对程序可见的范围。标识符在其潜在作用域内，并非在任何地方都是

可见的。例如，局部变量可以屏蔽全局变量、嵌套层次中的内层变量可以屏蔽外层变量，从而被屏蔽的全局或外层变量在其倍屏蔽的区域内是不可见的。

所以，一个标识符的作用域可能小于其潜在作用域。

l         命名空间

命名空间（namespace）是一种描述逻辑分组的机制，可以将按某些标准在逻辑上属于同一个集团的声明放在同一个命名空间中。

原来c 标识符的作用域分成三级：代码块（{……}，如复合语句和函数体）、类和全局。现在，在其中的类和全局之间，标准c 又添加了命名空间这一

个作用域级别。

命名空间可以是全局的，也可以位于另一个命名空间之中，但是不能位于类和代码块中。所以，在命名空间中声明的名称（标识符），默认具有外部链接

特性（除非它引用了常量）。

在所有命名空间之外，还存在一个全局命名空间，它对应于文件级的声明域。因此，在命名空间机制中，原来的全局变量，现在被认为位于全局命名空间

中。

标准c 库（不包括标准c库）中所包含的所有内容（包括常量、变量、结构、类和函数等）都被定义在命名空间std（standard标准）中了。

2）定义命名空间
有两种形式的命名空间——有名的和无名的。

命名空间的定义格式为：（取自c 标准文档）

named-namespace-definition:

       namespace identifier { namespace-body }

unnamed-namespace-definition:

       namespace { namespace-body }

namespace-body:

       declaration-seqopt

即：（自己翻译并改写的）

有名的命名空间：

       namespace 命名空间名 {

              声明序列可选

       }

无名的命名空间：

       namespace {

              声明序列可选

       }

命名空间的成员，是在命名空间定义中的花括号内声明了的名称。可以在命名空间的定义内，定义命名空间的成员（内部定义）。也可以只在命名空间的

定义内声明成员，而在命名空间的定义之外，定义命名空间的成员（外部定义）。

命名空间成员的外部定义的格式为：

命名空间名::成员名 ……

例如：

// out.h

namespace outer { // 命名空间outer的定义

       int i; // 命名空间outer的成员i的内部定义

       namespace inner { // 子命名空间inner的内部定义

              void f() { i ; } // 命名空间inner的成员f()的内部定义，其中的i为outer::i

              int i;

              void g() { i ; } // 命名空间inner的成员g()的内部定义，其中的i为inner::i

              void h(); // 命名空间inner的成员h()的声明

       }

       void f(); // 命名空间outer的成员f()的声明

       // namespace inner2; // 错误，不能声明子命名空间

}

void outer::f() {i--;} // 命名空间outer的成员f()的外部定义

void outer::inner::h() {i--;} // 命名空间inner的成员h()的外部定义

// namespace outer::inner2 {/*……*/} // 错误，不能在外部定义子命名空间

注意：

不能在命名空间的定义中声明（另一个嵌套的）子命名空间，只能在命名空间的定义中定义子命名空间。

也不能直接使用“命名空间名::成员名 ……”定义方式，为命名空间添加新成员，而必须先在命名空间的定义中添加新成员的声明。

另外，命名空间是开放的，即可以随时把新的成员名称加入到已有的命名空间之中去。方法是，多次声明和定义同一命名空间，每次添加自己的新成员和

名称。例如：

namespace a {

       int i;

       void f();

} // 现在a有成员i和f()

namespace a {

       int j;

       void g();

} // 现在a有成员i、f()、j和g()

还可以用多种方法，来组合现有的命名空间，让它们为我所用。例如：

namespace my_lib {

       using namespace his_string;

       using namespace her_vector;

       using your_list::list;

       void my_f(string &, list &);

}

……

using namespace my_lib;

……

vector vs[5];

list li[10];

my_f(vs[2], li[5]);

3）使用命名空间
l     作用域解析运算符（::）

对命名空间中成员的引用，需要使用命名空间的作用域解析运算符::。例如：

// out1.cpp

#include "out.h"

#include

int main ( ) {

       outer::i = 0;

       outer::f(); // outer::i = -1;

       outer::inner::f(); // outer::i = 0;

       outer::inner::i = 0;

       outer::inner::g(); // inner::i = 1;

       outer::inner::h(); // inner::i = 0;

       std::cout << "hello, world!" << std::endl;

       std::cout << "outer::i = " << outer::i << ",  inner::i = " << outer::inner::i << std::endl;

}

l     using指令（using namespace）

为了省去每次调用inner成员和标准库的函数和对象时，都要添加outer::inner::和sta::的麻烦，可以使用标准c 的using编译指令来简化对命名空间中

的名称的使用。格式为：

using namespace 命名空间名[::命名空间名……];

在这条语句之后，就可以直接使用该命名空间中的标识符，而不必写前面的命名空间定位部分。因为using指令，使所指定的整个命名空间中的所有成员

都直接可用。例如：

// out2.cpp

#include "out.h"

#include

// using namespace outer; // 编译错误，因为变量i和函数f()有名称冲突

using namespace outer::inner;

using namespace std;

int main ( ) {

       outer::i = 0;

       outer::f(); // outer::i = -1;

       f(); // inner::f()，outer::i = 0;

       i = 0; // inner::i

       g(); // inner::g()，inner::i = 1;

       h(); // inner::h()，inner::i = 0;

       cout << "hello, world!" << endl;

       cout << "outer::i = " << outer::i << ",  inner::i = " << i << endl;

}

又例如：（.net框架）

using namespace system::drawing::imaging;

using namespace system::window::forms::design::behavior;

l     using声明（using）

除了可以使用using编译指令（组合关键字using namespace）外，还可以使用using声明来简化对命名空间中的名称的使用。格式为：

using 命名空间名::[命名空间名::……]成员名;

注意，关键字using后面并没有跟关键字namespace，而且最后必须为命名空间的成员名（而在using编译指令的最后，必须为命名空间名）。

与using指令不同的是，using声明只是把命名空间的特定成员的名称，添加该声明所在的区域中，使得该成员可以不需要采用，（多级）命名空间的作用

域解析运算符来定位，而直接被使用。但是该命名空间的其他成员，仍然需要作用域解析运算符来定位。例如：

// out3.cpp

#include "out.h"

#include

using namespace outer; // 注意，此处无::inner

using namespace std;

// using inner::f; // 编译错误，因为函数f()有名称冲突

using inner::g; // 此处省去outer::，是因为outer已经被前面的using指令作用过了

using inner::h;

int main ( ) {

       i = 0; // outer::i

       f(); // outer::f()，outer::i = -1;

       inner::f(); // outer::i = 0;

       inner::i = 0;

       g(); // inner::g()，inner::i = 1;

       h(); // inner::h()，inner::i = 0;

       cout << "hello, world!" << endl;

       cout << "outer::i = " << i << ",  inner::i = " << inner::i << endl;

}

l     using指令与using声明的比较

可见，using编译指令和using声明，都可以简化对命名空间中名称的访问。

using指令使用后，可以一劳永逸，对整个命名空间的所有成员都有效，非常方便。而using声明，则必须对命名空间的不同成员名称，一个一个地去声明

，非常麻烦。

但是，一般来说，使用using声明会更安全。因为，using声明只导入指定的名称，如果该名称与局部名称发生冲突，编译器会报错。而using指令导入整

个命名空间中的所有成员的名称，包括那些可能根本用不到的名称，如果其中有名称与局部名称发生冲突，则编译器并不会发出任何警告信息，而只是用

局部名去自动覆盖命名空间中的同名成员。特别是命名空间的开放性，使得一个命名空间的成员，可能分散在多个地方，程序员难以准确知道，别人到底

为该命名空间添加了哪些名称。

虽然使用命名空间的方法，有多种可供选择。但是不能贪图方便，一味使用using 指令，这样就完全背离了设计命名空间的初衷，也失去了命名空间应该

具有的防止名称冲突的功能。

一般情况下，对偶尔使用的命名空间成员，应该使用命名空间的作用域解析运算符来直接给名称定位。而对一个大命名空间中的经常要使用的少数几个成

员，提倡使用using声明，而不应该使用using编译指令。只有需要反复使用同一个命名空间的许多数成员时，使用using编译指令，才被认为是可取的。

例如，如果一个程序（如上面的outi.cpp）只使用一两次cout，而且也不使用std命名空间中的其他成员，则可以使用命名空间的作用域解析运算符来直

接定位。如：

#include

……

std::cout << "hello, world!" << std::endl;

std::cout << "outer::i = " << outer::i << ",  inner::i = " << outer::inner::i << std::endl;

又例如，如果一个程序要反复使用std命名空间中的cin、cout和cerr（如上面的outi.cpp），而不怎么使用其他std命名空间中的其他成员，则应该使用

using 声明而不是using指令。如：

#include

……

using std::cout;

cout << "hello, world!" << endl;

cout << "outer::i = " << outer::i << ",  inner::i = " << outer::inner::i << endl;

4）命名空间的名称
l     命名空间别名

标准c 引入命名空间，主要是为了避免成员的名称冲突。若果用户都给自己的命名空间取简短的名称，那么这些（往往同是全局级的）命名空间本身，

也可能发生名称冲突。如果为了避免冲突，而为命名空间取很长的名称，则使用起来就会不方便。这是一个典型的两难问题。

标准c 为此提供了一种凯发app官方网站的解决方案——命名空间别名，格式为：

namespace 别名 = 命名空间名;

例如：（at&t美国电话电报公司）

namespace american_telephone_and_telegraph { // 命名空间名太长

       class string {

              string(const char*);

              // ……

       }

}

american_telephone_and_telegraph::string s1 // 使用不方便

= new american_telephone_and_telegraph::string("grieg");

namespace att = american_telephone_and_telegraph; // 定义别名

att::string s2 = new att::string("bush"); // 使用方便

att::string s3 = new att::string("nielsen");

l     无名命名空间

标准c 引入命名空间，除了可以避免成员的名称发生冲突之外，还可以使代码保持局部性，从而保护代码不被他人非法使用。如果你的目的主要是后者

，而且又为替命名空间取一个好听、有意义、且与别人的命名空间不重名的名称而烦恼的话，标准c 还允许你定义一个无名命名空间。你可以在当前编

译单元中（无名命名空间之外），直接使用无名命名空间中的成员名称，但是在当前编译单元之外，它又是不可见的。

无名命名空间的定义格式为：

namespace {

       声明序列可选

}

实际上，上面的定义等价于：（标准c 中有一个隐含的使用指令）

namespace $$$ {

       声明序列可选

}

using namespace $$$;

例如：

namespace {

       int i;

       void f() {/*……*/}

}

int main() {

       i = 0; // 可直接使用无名命名空间中的成员i

       f(); // 可直接使用无名命名空间中的成员f()

}