以下的東西是我在網上看到的東西，摘抄下來的，忘了出處。先向貢獻者表示感謝

        thinking in c++ 之static小結
本的含義是：“位置不變的某個東西“，這里指的是內存中的位置或者文件中的可見性
1，在c和c++中，static的兩種含義：
（1），靜態存儲。
（2），對一個特定的編譯單元來說是本地的，這個名字在這個單元或類之外不可見。

2，static對象將存儲在程序的靜態存儲區中，而不是在堆棧中。這個對象只在漢書第一次調用是初始化，其后不用再初始化。

3，對于靜態對象的初始化，零賦值只對預定義對象有效，用戶自定義的類型必須用構造函數初始化。

4，靜態對象的析構函數在程序的main()函數退出時，或者標準c函數exit()調用時才被調用。在析構函數中調用exit()是很危險的，因為這樣可能引起死循環。

5，靜態對象的銷毀是按它們初始化的相反順序進行的。全局對象總是在main()執行之前被創建。如果一個包含靜態對象的函數從沒有被調用過，那么這個對象的構造函數就沒有被執行，所以也就不會調用析構函數

6，一個被明確聲明為static的對象或函數的名字對編譯單元來說是局部變量，這些名字有內部連接。類聲明和局部變量沒有聯接。

7，extern表示該名字對所有的編譯單元是可見的，用static和extern限定的對象總是駐留在靜態數據區

8，普通函數是外部連接的

9，類的靜態成員擁有一塊單獨的存儲區,而不管我們創建了多少個該類的對象，這就為這些了創建了一個通信的方法。

10，靜態成員的定義必須出現在外部，而且只能有一次

11，一個類的靜態常量可以被用作一個編譯時常量

12，在局部類(在函數內部定義的類）中不能有靜態數據成員。

13，靜態成元函數：
（1），靜態成元函數為該類的全體服務，而不是為類的部分對象服務；
（2）,靜態成員函數不能訪問一般的數據成員，只能訪問靜態數據成員，并且只能調用靜態成元函數。

14，為什么靜態成元函數不能訪問一般的數據成員，也不能調用普通的成員函數?
由于當前對象的地址是被隱藏的傳遞給被調用的函數的，由于靜態成員函數不是某個對象獨有的，所以沒有this指針，所以無法調用調用普通成員函數，同樣對普通成員變量的訪問也用到了this指針。

        編譯單元
經過預處理之后的文件（這個是內存中的臨時文件）
#include在預處理時被展開，宏也一樣

一個經過展開后的.cpp文件就是一個編譯單元

一個xx.h（經過預處理） + 一個xx.cpp = 一個編譯單元
一個編譯單元（經過編譯）= xx.obj
整個程序的多個.obj加起來(經過鏈接) = .exe（可執行文件）

預處理
-----------
把一些帶#號的，比方說宏定義，預處理命令（#include）等

        內部連接與外部連接
在說內部連接與外部連接前，先說明一些概念。

　　1.聲明

　　一個聲明將一個名稱引入一個作用域;

　　在c++中，在一個作用域中重復一個聲明是合法的

　　以下都是聲明：

int foo(int,int); //函數前置聲明

typedef int Int; //typedef 聲明

class bar; //類前置聲明

extern int g_var; //外部引用聲明

class bar; //類前置聲明

typedef int Int; //typedef 聲明

extern int g_var; //外部引用聲明

friend test; //友員聲明

using std::cout; //名字空間引用聲明

friend test; //友員聲明

using std::cout; //名字空間引用聲明

int foo(int,int); //函數前置聲明 

　　在同一個作用域中你可以多次重復這些聲明。

　　有兩種聲明不能重復，那就是類成員函數及靜態數據成員的聲明

class foo
{
　static int i;
　static int i;//不可以
　public:
　　int foo();
　　int foo();//不可以
};

2.定義

　　一個定義提供一個實體(類型、實例、函數)在一個作用域的唯一描述。

　　在同一作用域中不可重復定義一個實體。

　　以下都是定義。

int y;

class foo ;

struct bar ;

foo* p;

static int i;

enum Color;

const double PI = 3.1415;

union Rep;

void test(int p) {};

foo a;

bar b;

　　3.編譯單元

　　當一個c或cpp文件在編譯時，預處理器首先遞歸包含頭文件，形成一個含有所有必要信息的單個源文件,這個源文件就是一個編譯單元。這個編譯單元會被編譯成為一個與cpp文件名同名的目標文件(.o或是.obj)。連接程序把不同編譯單元中產生的符號聯系起來，構成一個可執行程序。

　　4.自由函數

　　如果一個函數是自由函數，那么這個函數不是類的成員函數，也不是友元函數。

　　下面來看內部連接和外部連接

　　內部連接：如果一個名稱對于它的編譯單元來說是局部的，并且在連接時不會與其它編譯單元中的同樣的名稱相沖突，那么這個名稱有內部連接(注：有時也將聲明看作是無連接的，這里我們統一看成是內部連接的)。

　　以下情況有內部連接:

　　a)所有的聲明

　　b)名字空間(包括全局名字空間)中的靜態自由函數、靜態友元函數、靜態變量的定義

　　c)enum定義

　　d)inline函數定義(包括自由函數和非自由函數)

　　e)類的定義

　　f)名字空間中const常量定義

　　g)union的定義

　　外部連接:在一個多文件程序中，如果一個名稱在連接時可以和其它編譯單元交互，那么這個名稱就有外部連接。

　　以下情況有外部連接:

　　a)類非inline函數總有外部連接。包括類成員函數和類靜態成員函數

　　b)類靜態成員變量總有外部連接。

　　c)名字空間(包括全局名字空間)中非靜態自由函數、非靜態友元函數及非靜態變量

　　下面舉例說明：

　　a)聲明、enum定義、union定義有內部連接

　　所有的聲明、enum定義及union定義在編譯后不會產生連接符號，也就是在不同編譯單元中有相同名稱的聲明及enum、union定義并不會在連接時發生發現多個符號的錯誤。

// main.cpp

typedef int Int; //typedef 聲明，內部連接

enum Color; //enum定義,內部連接

union X //union定義，內部連接
{
　long a;
　char b[10];
};

int main(void)
{
Int i = red;
return i;
}

// a.cpp

typedef int Int; //在a.cpp中重聲明一個int類型別名，在連接時不會發生錯誤
enum Color; //在a.cpp中重定義了一個enum Color，在連接時不會發生錯誤
const Int i =blue; //const常量定義，內部連接
union X //union定義，內部連接
{
　long a;
　char b[10];
};

　　b)名字空間中靜態自由函數、靜態友元函數、靜態變量、const常量定義有內部連接

// main.cpp

namespace test
{
　int foo(); //函數聲明，內部連接
　static int i = 0; //名字空間靜態變量定義，內部連接
　static int foo() { return 0;} //名字空間靜態函數定義，內部連接
}

static int i = 0; //全局靜態變量定義，內部連接
static int foo() {return 1;} //全局靜態函數定義，內部連接
const int k = 0; //全局const常量定義，內部連接
int main(void)
{
　return 0;
}

//a.cpp

namespace test
{
　int i = 0; //名字空間變量定義，外部連接
　int foo() {return 0;} //名字空間函數定義，外部連接
}

int i = 0; //全局變量定義，外部連接
int k = 0; //全局變量定義，外部連接
int foo() { return 2;} //全局函數定義，外部連接

　　在全局名字空間中，main.cpp中定義了靜態變量i,常量k,及靜態自由函數foo等，這些都有內部連接。如果你將這些變量或函數的static或是const修飾符去掉，在連接時就會現multiply defined symbols錯誤，它們與a.cpp中的全局變量、全局函數發生沖突。

c)類定義總有內部連接,而非inline類成員函數定義總有外部連接，不論這個成員函數是靜態、虛擬還是一般成員函數，類靜態數據成員定義總有外部連接。

　　1.類的定義有內部連接。如果不是，想象一下你在4個cpp文件中include定義了類Base的頭文件，在4個編譯單元中的類Base都有外部連接，在連接的時候就會出錯。

　　看下面的例子:

//main.cpp

class B //類定義，內部連接
{
　static int s_i; //靜態類成員聲明，內部連接
　public:
　　void foo() { ++s_i;} //類inline函數，內部連接
};
struct D
{
　void foo(); //類成員函數聲明，內部連接
};

int B::s_i = 0; //類靜態數據成員定義，外部連接
void D::foo() //類成員函數定義，外部連接
{
　cout << "D::foo in main.cpp" <
}

int main() //main函數，全局自由函數，外部連接
{
　B b;
　D d;
　return 0;
}

//a.cpp

class B
{
　int k;
};

struct D
{
　int d;
}; 

　　在這個例子中，main.cpp與a.cpp中都有class B和class D的定義，但在編譯這兩個cpp文件時并不發生link錯誤。

　　2.類的非inline成員函數(一般，靜態，虛擬都是)總有外部連接，這樣當你include了某個類的頭文件，使用這個類的函數時，就能連接到正確的類成員函數上，繼續以上面為例子，如果把a.cpp中的struct D改為

struct D //類定義
{
　int d;
　void foo(); //類成員函數聲明
};
void D::foo() //類成員函數定義，外部連接
{
　cout << " D::foo in a.cpp" <
} 

　　這時main.cpp與a.cpp中的D::foo都有外部連接，在連接就會出現multiply defined symbols錯。

　　3.類的靜態數據成員有外部連接，如上例的B::s_i,這樣當你在main.cpp中定義了類靜態數據成員，其它編譯單元若使用了B::s_i,就會連接到main.cpp對應編譯單元的s_i。

　　d)inline函數總有內部連接，不論這個函數是什么函數

// main.cpp

inline int foo() { return 1;} //inline全局函數，內部連接
class Bar //類定義，內部連接
{
　public:
　　static int f() { return 2;} //inline 類靜態函數，內部連接
　　int g(int i) { return i;} //inline 類成員函數，內部連接
};

class Base
{
　public:
　　inline int k()； //類成員函數聲明，內部連接
}；

inline int Base::k(){return 5;} //inline 類成員函數，內部連接
int main(void)
{
　return 0;
}

　　如果你的Base類是定義在Base.h中，而Base的inline 函數是在Base.cpp中定義的，那么在main.cpp中include "Base.h"編譯不會出現問題，但在連接時會找不到函數k，所以類的inline函數最好放到頭文件中，讓每一個包含頭文件的cpp都能找到 inline函數。

　　現在對c++中的連接有了一個認識，能清楚的知道是什么原因產生連接時錯誤。當你在連接時產生連接不到的錯誤，這說明所有的編譯單元都沒有這個實體的外部連接；當你在連接時發現有多個連接實體，這說明有多個編譯單元提供了同名的有外部連接的實體。同時，在進行程序設計時，也要注意不要使只有本編譯單元用到的函數、類、變量等有外部連接，減少與其它編譯單元的連接沖突。

　　不過在這里沒有說明template函數及template class的連接性，并且對一些特別的情況也沒有作出說明(比如inline函數不能被inline)。

        編譯單元，是代碼的物理組織形式。有時在單個的‘.h’或‘.cpp’的編寫中看沒有問題的代碼，在編譯單元中就是有問題的。特別是軟件規模大時。

編譯器不會去編譯'.h'或者'.hpp'文件。
編譯器只會編譯'.c'或'.cpp'文件。

'.h'或'.hpp'里的代碼會被#include宏添加到'.c'或'.cpp'文件中。
這個過程發生在預編譯期，預編譯器（現在好像沒有這個東西了，都
在編譯器中完成）完成這份工作。

一個'.c'或'.cpp'是一個編譯單元。編譯器將其翻譯成二進制代碼。

        這是我在看boost MPL時試著翻譯的東西，現在貼上來。

A metafunction is a class or a class template that represents a function invocable at compile-time.
一個原操作是在編譯器表現了調用操作的一個類或一個模板類。

An non-nullary metafunction is invoked by instantiating the class template with particular template parameters (metafunction arguments);
一個非無參的原操作被一個有詳細模板參數的模板類請求；
the result of the metafunction application is accessible through the instantiation's nested type typedef.
原操作應用的返回值是一個通過模板類實例可取的內嵌的類型定義。

All metafunction's arguments must be types (i.e. only type template parameters are allowed).
所有的原操作的參數必須是類型。

A metafunction can have a variable number of parameters.
一個原操作能有一個數量變化的參數

A nullary metafunction is represented as a (template) class with a nested type typename member.
一個無參數原操作被表現為有內嵌重命名類型的類

原操作的三種表達式（f是一個原操作）
1 f::type
2 f<>::type
3 f< a1,..,an >::type

Lambda Expression 構造和分配表達式

A Lambda Expression is a compile-time invocable entity in either of the following two forms:
一個構造和分配表達式是下面兩個中的一個編譯期調用單元

Metafunction Class
原操作類

Placeholder Expression
站位符表達式

Most of the MPL components accept either of those, and the concept gives us a consice way to describe these requirements.
大部分的MPL組件接收它們其中一個，

        Modern C++ Design中實現了一個自動生成類的方法。它用的是Loki中的TypeList。我在這里使用了boost MPL中的vector來作為類型的容器。按boost MPL庫的設計理念，其他的類型容器也應該可以利用這里的實現的（沒有試過，可能有問題，特別是map類型容器）

        實現如下（注：我已將boost的頭文件放到了vc的include目錄中）
  
    #include < boost/mpl/vector.hpp >
    #include < boost/mpl/front.hpp >
    #include < boost/mpl/pop_front.hpp >

    template< typename Type >
    struct Holder
    {
        Type value_;
    };

    template< typename TypeSequeue, template< typename > class Unit >
    struct TypeConstract : public Unit< typename boost::mpl::front< TypeSequeue >::type >,
                           public TypeConstract< typename boost::mpl::pop_front< TypeSequeue >::type,
                                                 Unit >
    {
    };

    template< template< typename > class Unit >
    struct TypeConstract< boost::mpl::vector<>::type, Unit >
    {
    };                                                                                                                                                                      

        當一個類有虛函數時，它一定有一個虛表，用來紀錄每個虛函數的實際地址。這也就是說這個虛表的大小是在編譯期就確定了的。有多少個虛函數，虛表就紀錄幾個。
        類中的模板函數函數會根據具體的類型而實例化，這也就是說這個模板函數會實例多少個函數出來是不知道的，這樣，虛表的大小就不好確定了。所以在現有的編譯器的情況下，虛函數不能是模板函數。當然以后可能會支持這種情況。

       標準程序庫中的I/O class不局限于文件、屏幕或鍵盤，事實上它們形成了好呢個一套富有彈性的框架。可用來將任意數據格式化。可以處理（存取）任意外部表示。
        所謂stream就是一條數據“流”，字符序列在其中“川流不息”。按面向對象的原則，stream是由某個類別定義出來的具有特定性質的對象
        IOStream程序庫均不依賴任何特定的字符型別，而以一個tamplate參數替代之，有利于國際化（不同的字符集）。
        stream操作符，operator》和operator《被相應的stream class重載，分別用于輸入于輸出。
        控制器是專門用來操控stream的對象，常常只會改變輸入或格式化輸出解釋方式。
        用于ostream的操控器并不會憑空造出輸出數據，用于istream的操控器也不會吃掉任何輸入數據

??????? class CTest
??????? {
??????? public:
??????????????? CTest() {}
??????????????? ~CTest() {}

??????????????? int GetValue( void );

??????????????? int m_int;
??????? }

??????? CTest ct;
??????? CTest *pct = new CTest;

????????C++類成員對象指針（事例使用上面的類）

????????類型 類名::*????? 如下
??????? int CTest::*;
??????? typedef int CTest::* Member_Ptr;

??????? 賦值? Member_Ptr ptr = &CTest::m_int;
??????? 取值 int i = ct.*ptr?或 pct->*ctr;

??????? C++類成員函數指針（事例使用上面的類）

??????? 類型 (類名::*)( 參數列表 )???? 如下
??????? int (CTest::*)( void );
??????? typedef int (CTest::*Member_Fun_Ptr)( void );

??????? 賦值? Member_Fun_Ptr fun_ptr = &CTest::GetValue;
??????? 使用? int i = ct.*fun_ptr(); 或?pct->*fun_ptr();

??????? C++類成員函數還有引用，可是成員對象沒有引用
??????? int (CTest::&)( void );
??????? typedef int (CTest::&Member_Fun_Ref)( void );

??? boost庫中MPL部分提供了Data_Types。其中提供了對數字類型的一個wrapper
??? 有一下這么幾個，都在boost::mpl名字空間下
???
??? bool_ 是一個bool型的常量wrapper，頭文件 #include< boost/mpl/bool.hpp >
??? int_? 是一個int型的常量wrapper，頭文件 #include< boost/mpl/int.hpp >
??? long_ 是一個long型的常量wrapper，頭文件 #include< boost/mpl/long.hpp >
??? size_t 是一個std::size_t型的常量wrapper，頭文件 #include< boost/mpl/size_t.hpp >
??? integral_c 提供了對整形的一個通用wrapper，頭文件 #include< boost/mpl/integral_c.hpp >
???
??? 這些常量提供了如下的能力（假設一個常量類型 n ）
??? 獲得常量類型包含的類型 n::value_type
??? 獲得常量類型的類型???? n::type
??? 獲得常量類型的值?????? n::value
??? 返回常量類型的值?????? n()
???
??? bool_部分
???
??? bool_的聲明如下
???
??? template< bool C >
??? struct bool_;
???
??? 庫中定義了兩個常用的bool型常量，true_和false_。定義分別如下
??? typedef bool_< true > true_;
??? typedef bool_< false > false_;
???
??? bool_特性如下
??? bool_< true >::value_type == bool
??? bool_< true >::type == bool< true >
??? bool_< true >::value == true
??? bool_< true >() == true
???
??? int_部分
???
??? int_的聲明如下
???
??? template< int N >
??? struct int_;
???
??? int_特性如下
??? int_< 10 >::value_type == int;
??? int_< 10 >::type == int_< 10 >;
??? int_< 10 >::value == 10;
??? int_< 10 >() == 10;
???
??? long_部分
???
??? long_的聲明如下
???
??? template< long N >
??? struct long_;
???
??? long_特性如下
??? long_< -500 >::value_type == long;
??? long_< -500 >::type == long_< -500 >;
??? long_< -500 >::value == -500;
??? long_< -500 >() == -500;
???
??? size_t部分
???
??? size_t的聲明如下
???
??? template< std::size_t N >
??? struct size_t;
???
??? size_t的特性如下
??? size_t< 20 >::value_type == std::size_t;
??? size_t< 20 >::type == size_t< 20 >;
??? size_t< 20 >::value == 20;
??? size_t< 20 >() == 20;
???
??? integral_c部分
???
??? integral_c的聲明如下
??? template< typename T, T N >
??? struct integral_c;
???
??? integral_c的特性如下
??? integral_c< short, 8 >::value_type == short;
??? integral_c< short, 8 >::type == integral_c< short, 8 >;
??? integral_c< short, 8 >::value == 8;
??? integral_c< short, 8 >() == 8;

??????? 有了數組的引用，理解數組的指針就很簡單了。聲明如下
??????? 類型名 (*數組指針名)[N];
??????? 實例
??????? int (*pint_array)[10];

????????定義數組指針類型
??????? typedef 類型名 (*數組指針類型名)[N];
??????? 實例
????????typedef int (*Array_Pionter)[10];
??????? Array_Pionter是數組指針類型

??????? 細心的話，就會發現和函數指針的定義很象。以此類推，應該有函數應用，我在vc2003的編譯器下試驗成功過，有函數引用。

??????? 象如下定義就得到一個數組的引用
??????? 類型名 （&變量明）[N]；
???????
??????? 實例
??????? int int_array[10];
??????? int (&int_ref)[10] = int_array;
??????? 這樣就得到了一個數組的應用

??????? 在函數的聲明中用數組的引用定義，就不怕數組退化了。如下
??????? for_each( int (&int_ref)[10] )
??????? {
???????????????? for( int i=0; i<10; ++i?)
???????????????????????? std::cout << int_ref[i] << std::endl;
???????? }

???????? int main( int argc, char* argv[] )
???????? {
???????????????? int int_array[] = { 1, 2, 3, 4, 5,?6, 7, 8, 9, 10?}
????????
???????????????? for_each( int_array );
???????????????? return 0;
????????? }

??????????在上面的代碼中，如果你傳入不是10個尺寸的數組，是編譯通不過的。代碼的安全性提高了。???

???????? 想要定義一個數組引用類型，方法如下
???????? typedef?類型明 (&數組引用類型明)[N];

???????? 實例
???????? typedef int (&Array_Ref)[10];
???????? Array_Ref就是一個數組的引用類型了。