以下的东西是我在网上看到的东西，摘抄下来的，忘了出处。先向贡献者表示感谢

        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就是一个数组的引用类型了。