C++ 命名空間整理__C++

1.using:為了避免每次都使用名字空間是都要其進行名字空間限定可以使用using對名字空間內的內容進行特定地區的聲明using A::T;//using 聲明

再次使用可以直接調用名稱而無需增加空間限定

2.using:作為編譯指令的使用，使對應名字空間內的所有內容可用且使用時可以省略範圍解析運算子

using namespace A;

注意事項：

一，避免歧義using A::T;

  using B::T;

     T=1://哪一個。

二，using做編譯指令時命名空間為全域如果局部與命名空間的名字相同則局部覆蓋命名空間內容

三，局部名稱會覆蓋全域與using指令的命名空間內容但可以用T(局部)::T(全域) A::T(命名空間)區分使用

四，using聲明比using編譯安全。

聲明是置頂具體內容編譯器發出指示，編譯指令匯入全部命名空間內容可能發生衝突覆蓋時編譯器不會發出警告。

3.在子類中使用 using 聲明引入基類成員名稱（參見C++ primer）

在private或者protected繼承時，基類成員的存取層級在衍生類別中更受限：

class Base {

public:

std::size_t size() const { return n; }

protected:

std::size_t n;

};

class Derived : private Base { . . . };

在這一繼承層次中，成員函數 size 在 Base 中為 public，但在 Derived 中為 private。為了使 size 在 Derived 中成為 public，可以在 Derived 的 public

部分增加一個 using 聲明。如下這樣改變 Derived 的定義，可以使 size 成員能夠被使用者訪問，並使 n 能夠被 Derived的衍生類別訪問：

class Derived : private Base {

public:

using Base::size;

protected:

using Base::n;

// ...

};

另外，當子類中的成員函數和基類同名時，子類中重定義的成員函數將隱藏基類中的版本，即使函數原型不同也是如此（隱藏條件見下面）。

如果基類中成員函數有多個重載版本，衍生類別可以重定義所繼承的 0 個或多個版本，但是通過衍生類別型只能訪問衍生類別中重定義的那些版本，所以如果衍生類別想通過自身類型使用所有的重載版本，則衍生類別必須要麼重定義所有重載版本，要麼一個也不重定義。有時類需要僅僅重定義一個重載集中某些版本的行為，並且想要繼承其他版本的含義，在這種情況下，為了重定義需要特化的某個版本而不得不重定義每一個基類版本，可能會令人厭煩。可以在衍生類別中為重載成員名稱提供 using 聲明（為基類成員函數名稱而作的 using 聲明將該函數的所有重載執行個體加到衍生類別的範圍），使衍生類別不用重定義所繼承的每一個基類版本。一個 using 聲明只能指定一個名字，不能指定形參表，使用using聲明將名字加入範圍之後，衍生類別只需要重定義本類型確實必須定義的那些函數，對其他版本可以使用繼承的定義。

“隱藏”是指衍生類別的函數屏蔽了與其同名的基類函數，規則如下：

1、如果衍生類別的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數將被隱藏（注意別與重載混淆）

2、如果衍生類別的函數與基類的函數同名，並且參數也相同，但是基類函數沒有virtual關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）

#include "StdAfx.h"

#include <iostream>

using namespace std;

class Base

{

public:    

   void menfcn()

  {

     cout<<"Base function"<<endl;

  }

 

    void menfcn(int n)

    {

     cout<< cout<<"Base function with int"<<endl;

    }

 

};

class Derived : Base

{

public:    

using Base::menfcn;//using聲明只能指定一個名字，不能帶形參表    

int menfcn(int)

{ cout<< cout<<"Derived function with int"<<endl; }

};

int main()

{    Base b;

     Derived d;   

  b.menfcn();   

  d.menfcn();//如果去掉Derived類中的using聲明，會出現錯誤：error C2660: 'Derived::menfcn' : function does not take 0 arguments    std::cin.ignore(std::cin.gcount()+1);//清空緩衝區    std::cin.get();//暫停程式執行  

}

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

一、 為什麼需要命名空間（問題提出）

命名空間是ANSIC++引入的可以由使用者命名的範圍，用來處理常式中常見的同名衝突。

在C語言中定義了3個層次的範圍，即檔案(編譯單元)、函數和複合陳述式。C++又引入了類範圍，類是出現在檔案內的。在不同的範圍中可以定義相同名字的變數，互不於擾，系統能夠區別它們。

1、全域變數的範圍是整個程式，在同一範圍中不應有兩個或多個同名的實體(enuty)，包括變數、函數和類等。

例：如果在檔案中定義了兩個類，在這兩個類中可以有同名的函數。在引用時，為了區別，應該加上類名作為限定：
class A //聲明A類
{ public：
 void funl()；//聲明A類中的funl函數
private： 
 int i； }；
void A::funl() //定義A類中的funl函數
{…………}

class B //聲明B類
{ public：
 void funl()； //B類中也有funl函數
void fun2()； }；
 void B::funl() //定義B類中的funl函數
{ …………}
這樣不會發生混淆。

在檔案中可以定義全域變數(global variable)，它的範圍是整個程式。如果在檔案A中定義了一個變數a int a=3；
在檔案B中可以再定義一個變數a int a=5;
在分別對檔案A和檔案B進行編譯時間不會有問題。但是，如果一個程式包括檔案A和檔案B，那麼在進行串連時，會報告出錯，因為在同一個程式中有兩個同名的變數，認為是對變數的重複定義。
可以通過extern聲明同一程式中的兩個檔案中的同名變數是同一個變數。如果在檔案B中有以下聲明：
 extem int a；
表示檔案B中的變數a是在其他檔案中已定義的變數。由於有此聲明，在程式編譯和串連後，檔案A的變數a的範圍擴充到了檔案B。如果在檔案B中不再對a賦值，則在檔案B中用以下語句輸出的是檔案A中變數a的值： cout<<a； //得到a的值為3
2、程式中就會出現名字衝突。
在簡單的程式設計中，只要人們小心注意，可以爭取不發生錯誤。但是，一個大型的應用軟體，往往不是由一個人獨立完成的，而是由若干人合作完成的，不同的人分別完成不同的部分，最後組合成一個完整的程式。假如不同的人分別定義了類，放在不同的標頭檔中，在主檔案(包含主函數的檔案)需要用這些類時，就用#include命令列將這些標頭檔包含進來。由於各標頭檔是由不同的人設計的，有可能在不同的標頭檔中用了相同的名字來命名所定義的類或函數。

例4 名字衝突

程式員甲在標頭檔headerl．h中定義了類Student和函數fun。

//例4中的標頭檔header1(標頭檔1，沒其檔案名稱為cc8-4-h1.h)
#include <string>
#include <cmath>
using namespace std;
class Student //聲明Student類
{ public:
Student(int n,string nam,int a)
{ num=n;name=nam;age=a;}
void get_data();
private:
int num;
string name;
int age; };
void Student::get_data() //成員函數定義
{ cout<<num<<" "<<name<<" "<<age<<endl; }
double fun(double a,double b)//定義全域函數(即外部函數)
{ return sqrt(a+b);}

在main函數所在的檔案中包含標頭檔headerl.h：
#include <iostream>
using namespace std;
#include "header1.h" //注意要用雙引號，因為檔案一般是放在用使用者目錄中的
int main()
{ Student stud1(101,"Wang",18); //定義類對象studl
stud1.get_data();
cout<<fun(5,3)<<endl;
return 0; }

程式能正常運行，輸出為
101 Wang 18
2.82843

如果程式員乙寫了標頭檔header2．h，在其中除了定義其他類以外，還定義了類Student和函數fun，但其內容與標頭檔headerl．h中的Student和函數fun有所不同。

//例4中的標頭檔header2
#include <string>
#include <cmath>
using namespace std;
class Student //聲明Student類
{ public:
Student(int n,string nam,char s) //參數與headerl中的student不同
{ num=n;name=nam;sex=s;}
void get_data();
private:
int num;
string name;
char sex; };//此項與headerl不同

void Student::get_data() //成員函數定義
{ cout<<num<<" "<<name<<" "<<sex<<endl; }

double fun(double a,double b) //定義全域函數
{ return sqrt(a-b);} //傳回值與headerl中的fun函數不同
//標頭檔2中可能還有其他內容

假如主程式員在其程式中要用到headerl．h中的Student和函數fun，因而在程式中包含了標頭檔headerl．h，同時要用到標頭檔header2．h中的一些內容(但對header2．h中包含與headerl.h中的Student類和fun函數同名而內容不同的類和函數並不知情，因為在一個標頭檔中往往包含許多不同的資訊，而使用者往往只關心自己所需要的部分，而不注意其他內容)，因而在程式中又包含了標頭檔header2．h。如果主檔案(包含主函數的檔案)如下：

#include <iostream>
using namespace std;
#include "header1.h"//包含標頭檔l
#include "header2.h"//包含標頭檔2
int main()
{ Student stud1(101,"Wang",18);
stud1.get_data();
cout<<fun(5,3)<<endl;
return 0; }

這時程式編譯就會出錯。因為在先行編譯後，標頭檔中的內容取代了對應的#include命令列，這樣就在同一個程式檔案中出現了兩個Student類和兩個fun函數，顯然是重複定義，這就是名字衝突，即在同一個範圍中有兩個或多個同名的實體。

3、全域命名空間汙染(global namespace pollution)。
在程式中還往往需要引用一些庫(包括C++編譯系統提供的庫、由軟體開發商提供的庫或者使用者自己開發的庫)，為此需要包含有關的標頭檔。如果在這些庫中包含有與程式的全域實體同名的實體，或者不同的庫中有相同的實體名，則在編譯時間就會出現名字衝突。

為了避免這類問題的出現，人們提出了許多方法，例如：將實體的名字寫得長—些(包含十幾個或幾十個字母和字元)；把名字起得特殊一些，包括一些特殊的字元；由編譯系統提供的內部全域識別碼都用底線作為首碼，如_complex()，以避免與使用者命名的實體同名；由軟體開發商提供的實體的名字用特定的字元作為首碼。但是這樣的效果並不理想，而且增加了閱讀程式的難度，可讀性降低了。

C語言和早期的C++語言沒有提供有效機制來解決這個問題，沒有使庫的提供者能夠建立自己的命名空間的工具。人們希望ANSI C++標準能夠解決這個問題，提供—種機制、一種工具，使由庫的設計者命名的全域識別碼能夠和程式的全域實體名以及其他庫的全域識別碼區別開來。

二、 什麼是命名空間（解決方案）

命名空間：實際上就是一個由程式設計者命名的記憶體地區，程式設計者可以根據需要指定一些有名字的空間域，把一些全域實體分別放在各個命名空間中，從而與其他全域實體分隔開來。

如： namespace ns1 //指定命名中間nsl
{ int a；
 double b; }

namespace是定義命名空間所必須寫的關鍵字，nsl是使用者自己指定的命名空間的名字(可以用任意的合法標識符，這裡用ns1是因為ns是namespace的縮寫，含義請楚)，在花括弧內是聲明塊，在其中聲明的實體稱為命名空間成員(namespace member)。現在命名空間成員包括變數a和b，注意a和b仍然是全域變數，僅僅是把它們隱藏在指定的命名空間中而已。如果在程式中要使用變數a和b，必須加上命名空間名和範圍分辨符“::”，如nsl::a，nsl::b。這種用法稱為命名空間限定(qualified)，這些名字(如nsl::a)稱為被限定名(qualified name)。C++中命名空間的作用類似於作業系統中的目錄和檔案的關係，由於檔案很多，不便管理，而且容易重名，於是人們設立若干子目錄，把檔案分別放到不同的子目錄中，不同子目錄中的檔案可以同名。調用檔案時應指出檔案路徑。

命名空間的作用：是建立一些互相分隔的範圍，把一些全域實體分隔開來。以免產生老點名叫李相國時，3個人都站起來應答，這就是名字衝突，因為他們無法辨別老師想叫的是哪一個李相國，同名者無法互相區分。為了避免同名混淆，學校把3個同名的學生分在3個班。這樣，在小班點名叫李相國時，只會有一個人應答。也就是說，在該班的範圍(即班範圍)內名字是惟一的。如果在全校集合時校長點名，需要在全校範圍內找這個學生，就需要考慮範圍問題。如果校長叫李相國，全校學生中又會有3人一齊喊“到”，因為在同一範圍中存在3個同名學生。為了在全校範圍內區分這3名學生，校長必須在名字前加上班號，如高三甲班的李相國，或高三乙班的李相國，即加上班名限定。這樣就不致產生混淆。

可以根據需要設定許多個命名空間，每個命名空間名代表一個不同的命名空間域，不同的命名空間不能同名。這樣，可以把不同的庫中的實體放到不同的命名空間中，或者說，用不同的命名空間把不同的實體隱蔽起來。過去我們用的全域變數可以理解為全域命名空間，獨立於所有有名的命名空間之外，它是不需要用namespace聲明的，實際上是由系統隱式聲明的，存在於每個程式之中。

在聲明一個命名空間時，花括弧內不僅可以包括變數，而且還可以包括以下類型：

·變數(可以帶有初始化)；
·常量；
·數(可以是定義或聲明)；
·結構體；
·類；
·模板；
·命名空間(在一個命名空間中又定義一個命名空間，即嵌套的命名空間)。

例如

namespace nsl
{ const int RATE=0.08； //常量
doublepay； //變數
doubletax() //函數
{return a*RATE；}
namespacens2 //嵌套的命名空間
{int age；}
}
如果想輸出命名空間nsl中成員的資料，可以採用下面的方法：

cout<<nsl::RATE<<endl；
cout<<nsl::pay<<endl；
cout<<nsl::tax()<<endl；
cout<<nsl::ns2::age<<endl； //需要指定外層的和內層的命名中間名

可以看到命名空間的聲明方法和使用方法與類差不多。但它們之間有一點差別：在聲明類時在右花括弧的後面有一分號，而在定義命名空間時，花括弧的後面沒有分號。

三、 使用命名空間解決名字衝突（使用指南）

有了以上的基礎後，就可以利用命名空間來解決名字衝突問題。現在，對例4程式進行修改，使之能正確運行。

例5 利用命名空間來解決例4程式名字衝突問題。
修改兩個標頭檔，把在標頭檔中聲明的類分別放在兩個不同的命名空間中。
//例8.5中的標頭檔1，檔案名稱為header1.h

using namespace std;
#include <string>
#include <cmath>
namespace ns1 //聲明命名空間ns1
{ class Student //在命名空間nsl內聲明Student類 
{ public:
Student(int n,string nam,int a)
{ num=n;name=nam;age=a;}
void get_data();
private:
int num;
string name;
int age; };
void Student::get_data() //定義成員函數
{ cout<<num<<" "<<name<<" "<<age<<endl; }

double fun(double a,double b) //在命名空間n引內定義fun函數
{ return sqrt(a+b);}
}

//例8.5中的標頭檔2，檔案名稱為header2.h
#include <string>
#include <cmath>
namespace ns2 //聲明命名空間ns2
{ class Student
{ public:
Student(int n,string nam,char s)
{ num=n;name=nam;sex=s;}
void get_data();
private:
int num;
string name;
char sex; };

void Student::get_data()
{ cout<<num<<" "<<name<<" "<<sex<<endl; }

double fun(double a,double b)
{ return sqrt(a-b);}
}

//main file
#include <iostream>
#include "header1.h" //包含標頭檔l
#include "header2.h" //包含標頭檔2
int main()
{ ns1::Student stud1(101,"Wang",18);//用命名空間nsl中聲明的Student類定義studt
stud1.get_data(); //不要寫成ns1::studl.get_data()； 
cout<<Ns1::fun(5,3)<<endl; //調用命名空間ns1中的fun函數
ns2::Student stud2(102,"Li",'f'); //用命名空間ns2中聲明的Student類定義stud2
stud2.get_data();
cout<<ns2::fun(5,3)<<endl; //調用命名空間nsl，中的fun函數
return 0; }

解決本題的關鍵是建立了兩個命名空間nsl和ns2，將原來在兩個標頭檔中聲叫的類分別放在命名空間nsl和ns2中。注意：在標頭檔中，不要把#include命令放在命名空間中，在上一小節的敘述中可以知道，命名空間中的內容不包括命令列，否則編譯會出錯。

分析例4程式出錯的原因是：在兩個標頭檔中有相同的類名Student和相同的函數名fun，在把它們包含在主檔案中時，就產生名字衝突，存在重複定義。編譯系統無法辨別用哪一個標頭檔中的Student來定義對象studl。現在兩個Student和fun分別放在不同的命名空間中，各自有其範圍，互不相干。由於範圍不相同，不會產：生名字衝突。正如同在兩個不同的類中可以有同名的變數和函數而不會產生衝突一樣。

在定義對象時用ns1::Student(命名空間nsl中的Student)來定義studl，用ns2：：Student(命名空間ns2中的Student)來定義stud2。顯然，nsl::Student和ns2::Student是兩個不同的類，不會產生混淆。同樣，在調用fun函數時也需要用命名空間名ns]或ns2加以限定。ns1::fun()和ns2::fun()是兩個不同的函數。注意：對象studl是用nsl：：Student定義的，但對象studl並不在命名空間nsl中。studl的範圍為main函數範圍內。在調用對象studl的成員函數get_data時，應寫成studl．get_data()，而不應寫成nsl::studl.get_data()。

程式能順利通過編譯，並得到以下運行結果：
101 Wang l9 (對象studl中的資料)
2.82843 (／5+3的值)
102 Li f (對象studg中的資料)
1.41421 (／5-2的值)

四、 使用命名空間成員的方法

從上面的介紹可以知道，在引用命名空間成員時，要用命名空間名和範圍分辨符對命名空間成員進行限定，以區別不同的命名空間中的同名標識符。即:

命名空間名：：命名空間成員名

這種方法是有效，能保證所引用的實體有惟一的名字。但是如果命名空間名字比較長，尤其在有命名空間嵌套的情況下，為引用一個實體，需要寫很長的名字。在一個程式中可能要多次引用命名空間成員，就會感到很不方便。

1 、使用命名空間別名

可以為命名空間起一個別名(namespace alias)，用來代替較長的命名空間名。如

namespace Television //聲明命名空間，名為Television
{ ... }

可以用一個較短而易記的別名代替它。如：

namespace TV=Television； //別名TV與原名Television等價

也可以說，別名TV指向原名Television，在原來出現Television的位置都可以無條件地用TV來代替。

2、使用using命名空間成員名

using後面的命名空間成員名必須是由命名空間限定的名字。例如：

using nsl::Student；

以上語句聲明：在本範圍(using語句所在的範圍)中會用到命名空間ns1中的成員Student，在本範圍中如果使用該命名空間成員時，不必再用命名空間限定。例如在用上面的using聲明後，在其後程式中出現的Student就是隱含地指nsl::Student。

using聲明的有效範圍是從using語句開始到using所在的範圍結束。如果在以上的using語句之後有以下語句：

Student studl(101,"Wang",18)； //此處的Student相當於ns1::Student

上面的語句相當於

nsl::Student studl(101，"Wang"，18)；

又如

using nsl::fun； //聲明其後出現的fun是屬於命名空間nsl中的fun
cout<<fun(5，3)<<endl；//此處處的fun函數相當於nsl::fun(5，3)

顯然，這可以避免在每一次引用命名空間成員時都用命名空間限定，使得引用命名空間成員變得方便易用。
但是要注意：在同一範圍中用using聲明的不同命名空間的成員中不能有同名的成員。例如：

usmgnsl::Student； //聲明其後出現的Student是命名空間nsl中的Student
usmgns2::Student； //聲明其後出現的Student是命名空間ns2小的Student

Student stud1； //請問此處的Student是哪個命名中間中的Student?

產生了二義性，編譯出錯。

3、使用using namespace命名空間名

用上面介紹的using命名空間成員名，一次只能聲明一個命名空間成員，如果在一個命名空間中定義了10個實體，就需要使用10次using命名空間成員名。能否在程式中用一個語句就能一次聲明一個命名空間中的全部成員呢?

C++提供了using namespace語句來實現這一目的。using namespace語句的一般格式為

using namespace 命名空間名；

例如

using nanlespace nsl；

聲明了在本範圍中要用到命名空間nsl中的成員，在使用該命名空間的任何成員時都不必用命名空間限定。如果在作了上面的聲明後有以下語句：

Student studl(101，”Wang”，18)； //Student隱含指命名中間nsl中的Student
cout<<fun(5，3)<<endl； //這裡的fun函數是命名中間nsl中的fun函數

在用usmgnamespace聲明的範圍中，命名空間nsl的成員就好像在全域域聲明的一樣。因此可以不必用命名空間限定。顯然這樣的處理對寫程式比較方便。但是如果同時用usingnamespace聲明多個命名空間時，往往容易出錯。例5中的main函數如果用下面程式段代替，就會出錯。

int main()
{ using namespace nsl；//聲明nsl中的成員在本範圍中可用
using namespace ns2；//聲明ns2中的成員在本範圍中可用
Student studl(101，”Wang"，18)；
studl.8ct_data()；
cout<<fun(5,3)<<endl；
Student stud2(102，"Li"，'r')；
stud2.get_data()；
coutt<<fun(5，3)<<endl；
return O； }

因為在同一範圍中同時引入了兩個命名空間nsl和ns2，其中有同名的類和函數。在出現Student時，無法判定是哪個命名空間中的Student，出現二義性，編譯出錯。因此只有在使用命名空間數量很少，以及確保這些命名空間中沒有同名成員時才用using namespace語句。

五、 無名的命名空間

以上介紹的是有名字的命名空間，C++還允許使用沒有名字的命名空間，如在檔案A中聲明了以下的無名命名空間：

namespace //命名空間沒有名字
{ void fun( ) //定義命名空間成員
{ cout<<"OK．"<<endl；}
}

由於命名空間沒有名字，在其他檔案中顯然無法引用，它只在本檔案的範圍內有效。無名命名空間的成員fun函數的範圍為檔案A(確切地說，是從聲明無名命名空間的位置開始到檔案A結束)。在檔案A中使用無名命名空間的成員，不必(也無法)用命名空間名限定。

如果在檔案A中有以下語句：
fun()；
則執行無名命名空間中的成員fun函數，輸出”OK．”。

在本程式中的其他檔案中也無法使用該fun函數，也就是把fun函數的範圍限制在本檔案範圍中。可以聯想到：在C浯言中可以用static聲明一個函數，其作用也是使該函數的範圍限於本檔案。C++保留了用static聲明函數的用法，同時提供了用無名命名空間來實現這一功能。隨著越來越多的C++編譯系統實現了ANSI C++建議的命名空間的機制，相信使用無名命名空間成員的方法將會取代以前習慣用的對全域變數的靜態聲明。

六、標準命名空間std

為瞭解決C++標準庫中的標識符與程式中的全域識別碼之間以及不同庫中的標識符之間的同名衝突，應該將不同庫的標識符在不同的命名空間中定義(或聲明)。標準C++庫的所有的標識符都是在一個名為std的命名空間中定義的，或者說標準標頭檔(如iostream)中函數、類、對象和類模板是在命名空間std中定義的。std是standard(標準)的縮寫，表示這是存放標準庫的有關內容的命名空間，含義請楚，不必死記。
這樣，在程式中用到C++標準庫時，需要使用std作為限定。如

std::cout<<"OK．"<<endl； //聲明cout是在命名空間std中定義的流對象

在有的C++書中可以看到這樣的用法。但是在每個cout，cm以及其他在std中定義的標識符前面都用命名空間std作為限定，顯然是很不方便的。在大多數的C++程式中常用usmgnamespace語句對命名空間std進行聲明，這樣可以不必對每個命名空間成員一進行處理，在檔案的開頭加入以下using namespace聲明：

using namespace std；

這樣，在std中定義和聲明的所有標識符在本檔案中都可以作為全域量來使用。但是應當絕對保證在程式中不出現與命名空間std的成員同名的標識符，例如在程式中不能再定義一個名為cout的對象。由於在命名空間std中定義的實體實在太多，有時程式設計人員也弄不請哪些標識符已在命名空間std中定義過，為減少出錯機會，有的專業人員喜歡用若干個"using命名空間成員”聲明來代替“using namespace命名空間”聲明，如

using Std::string；
using Std::cout；
using Std::cin；

等。為了減少在每一個程式中都要重複書寫以亡的using聲明，程式開發人員往往把編寫應用程式時經常會用到的命名空間std成員的usmg聲明組成一個標頭檔，然後在程式中包含此標頭檔即可。

如果閱讀了多種介紹C++的書，可能會發現有的書的程式中有using namespace語句，有的則沒有。有的讀者會提出：究竟應該有還是應該沒有?應當說：用標準的C++編程，是應該對命名空間std的成員進行聲明或限定的(可以採取前面介紹過的任一種方法)。但是目前所用的C++庫大多是幾年前開發的，當時並沒有命名空間，庫中的有關內容也沒有放在std命名空間中，因而在程式中不必對std進行聲明。

七、 使用早期的函數庫

C語言程式中各種功能基本上都是由函數來實現的，在C語言的發展過程中建立了功能豐富的函數庫，C++從C語言繼承了這份寶貴的財富。在C++程式中可以使用C語言的函數庫。

如果要用函數庫中的函數，就必須在程式檔案中包含有關的標頭檔，在不同的標頭檔中，包含了不同的函數的聲明。

在C++中使用這些標頭檔有兩種方法。

1、用C語言的傳統方法
標頭檔名包括尾碼．h，如stdio.h，math.h等。由於C語言沒有命名空間，標頭檔並不存放在命名空間中，因此在C++程式檔案中如果用到帶尾碼．h的標頭檔時，不必用命名空間。只需在檔案中包含所用的標頭檔即可。如

#include<math．h>

2、用C++的新方法
C++標準要求系統提供的標頭檔不包括尾碼．h，例如iostream、string。為了表示與C語言的標頭檔有聯絡又有區別，C++所用的標頭檔名是在C語言的相應的標頭檔名(但不包括尾碼．h)之前加一字母c。例如，C語言中有關輸入與輸出的標頭檔名為stdio．h在C++中相應的標頭檔名為cstdio。C語言中的標頭檔math.h，在C++中相應的頭文什名為cmath。C語言中的標頭檔string．h在C++中相應的標頭檔名為cstring。注意在C++中，標頭檔cstnng和標頭檔strmg不是同一個檔案。前者提供C語言中對字串處理的有關函數(如strcmp，ctrcpy)的聲明，後者提供C++中對字串處理的新功能。

此外，由於這些函數都是在命名空間std中聲明的，因此在程式中要對命名空間std作聲明。如：

#include<cstdio>
#include<cmath>
using namespace std；

目前所用的大多數C++編譯系統既保留了c的用法，又提供丁C++的新方法。下面兩種用法等價，可以任選。

C傳統方法 C++新方法
#include<stdio.h> #include<cstdio>
#include<math.h> #include<cmath>
#include<string.h> #include<cstring>
using namespace std；

可以使用傳統的c方法，但應當提倡使用C++的新方法。

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

c++官網的翻譯

命名空間是一個聲明性地區，為其內部的標識符（類型、函數和變數等的名稱）提供一個範圍。 命名空間用於將程式碼群組織到邏輯組中，還可用於避免名稱衝突，尤其是在基本程式碼封裝括多個庫時。 命名空間範圍內的所有標識符彼此可見，而沒有任何限制。 命名空間之外的標識符可通過使用每個標識符的完全限定名（例如 std::vector<std::string> vec;）來訪問成員，也可通過單個標識符的 using 聲明 (using std::string) 或命名空間中所有標識符的 using 指令 (C++) (using namespace std;) 來訪問成員。 標頭檔中的代碼應始終使用完整命名空間名稱。

下面的樣本示範了一個命名空間聲明和命名空間之外的代碼可訪問其成員的三種方法。

namespace ContosoData{        class ObjectManager     {    public:        void DoSomething() {}    };    void Func(ObjectManager) {}}

使用完全限定名：