static const inline

一static

1)产生背景

引出原因：函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题:如果想将函数中此变量的值保存至下一次调用时，如何实现？

最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。

      类的静态成员也是这个道理。

解决方案：因此C++中引入了static，用它来修饰变量，它能够指示编译器将此变量在程序的静态存储区分配空间保存，这样即实现了目的，又使得此变量的存取范围不变。

2)具体作用

Static作用分析总结：static总是使得变量或对象的存储形式变成静态存储，连接方式变成内部连接，对于局部变量（已经是内部连接了），它仅改变其存储方式；对于全局变量（已经是静态存储了），它仅改变其连接类型。(1连接方式：成为内部连接；2存储形式：存放在静态全局存储区)

二const

1)产生背景

a) C++有一个类型严格的编译系统，这使得C++程序的错误在编译阶段即可发现许多，从而使得出错率大为减少，因此，也成为了C++与C相比，有着突出优点的一个方面。

b) C中很常见的预处理指令#define VariableName VariableValue可以很方便地进行值替代，这种值替代至少在三个方面优点突出：

一是避免了意义模糊的数字出现，使得程序语义流畅清晰，如下例：

　　#define USER_NUM_MAX 107这样就避免了直接使用107带来的困惑。

二是可以很方便地进行参数的调整与修改，如上例，当人数由107变为201时，改动此处即可；

三是提高了程序的执行效率，由于使用了预编译器进行值替代，并不需要为这些常量分配存储空间，所以执行的效率较高。

然而，预处理语句虽然有以上的许多优点，但它有个比较致命的缺点，即，预处理语
句仅仅只是简单值替代，缺乏类型的检测机制。这样预处理语句就不能享受C++严
格类型检查的好处，从而可能成为引发一系列错误的隐患。

Const推出的初始目的，正是为了取代预编译指令（#开头），消除它的缺点，同时继承它的优点。

现在它的形式变成了：

Const DataType VariableName = VariableValue ;

2)具体作用

1.const用于指针的两种情况分析：

　   int const *A;　//A可变，*A不可变

　   int *const A;　//A不可变，*A可变

　分析：const是一个左结合的类型修饰符，它与其左侧的类型修饰符和为一个

类型修饰符，所以，int const限定*A,不限定A。int *const限定A,不限定*A。

2.const限定函数的传递值参数：

　   void Fun(const int Var);

　   分析：上述写法限定参数在函数体中不可被改变。

3.const限定函数的值型返回值：

const int Fun1();

const MyClass Fun2();

　   分析:上述写法限定函数的返回值不可被更新，当函数返回内部的类型时（如Fun1），已经是一个数值，当然不可被赋值更新，所以，此时const无意义，最好去掉，以免困惑。当函数返回自定义的类型时（如Fun2），这个类型仍然包含可以被赋值的变量成员，所以，此时有意义。

4.传递与返回地址：此种情况最为常见，由地址变量的特点可知，适当使用const，意义昭然。

5.　const限定类的成员函数：

class ClassName {

　public:

　　int Fun() const;

　.....

}

　　注意：采用此种const后置的形式是一种规定，亦为了不引起混淆。在此函数的声明中和定义中均要使用const,因为const已经成为类型信息的一部分。

获得能力：可以操作常量对象。

失去能力：不能修改类的数据成员，不能在函数中调用其他不是const的函数。

三inline

1)产生背景

inline这个关键字的引入原因和const十分相似，inline关键字用来定义一个类的内联函数，引入它的主要原因是用它替代C中

表达式形式的宏定义。

表达式形式的宏定义一例：

　　　#define ExpressionName(Var1,Var2) (Var1+Var2)*(Var1-Var2)

      这种表达式形式宏形式与作用跟函数类似，但它使用预编译器，没有堆栈，使用上比函数高效。但它只是预编译器上符号表的简单替换，不能进行参数有效性检测及使用C++类的成员访问控制。

inline推出的目的，也正是为了取代这种表达式形式的宏定义，它消除了它的缺点，同时又很好地继承了它的优点。inline代码放入预编译器符号表中，高效；它是个真正的函数，调用时有严格的参数检测；它也可作为类的成员函数。

2)具体作用

直接在class类定义中定义各函数成员，系统将他们作为内联函数处理；成员函数是内联函数，意味着：每个对象都有该函数一份独立的拷贝。

在类外，如果使用关键字inline定义函数成员，则系统也会作为内联函数处理。

附：

1999年2月《Embedded Systems Programming》上刊登的《const T vs. T const》,作者是Dan Saks。

观点1：

      任何一个申明都由两主要部分组成：一个或者几个限定符(declaration specifier)和一序列由逗号隔开的申明变量(declarator)。举个例子：static unsigned long int    *x[N]；
其中：static unsigned long int   限定符部分；

          *x[N]       申明变量部分；

申明变量部分是要申明的变量的名字，它可能和* , [] , () , &(for C++)结合起来使用。我们知道，*用于申明表示变量是指针类型；[]意味着数组；()有两种用法，第一种是作为函数调用操作符；另外一种是用作分组符。

        对于上面的例子，x是指向数组(数组元素类型是static unsigned long int)的指针，还是x是一个数组，数组的元素是static unsigned long int* 类型呢？为此，引入观点2。

观点2：

        申明变量中如果有操作符(例如 * [] ),按照表达式运算中的优先级规则进行处理。
        我们知道，在表达式运算中，* 的优先级比 [] 低。同样在申明变量的处理也是如此。如此以来，上面的疑问就可以解决了。我们看declarator部分：*x[N]；由于[]的优先级比较高，所以x是一个数组在x是一个指针之前。如此以来，*就用来修饰数组元素了。

        对于()，如果用作函数调用，它得优先级和[]一样；如果是用于分组作用，它得优先级最高。

观点3：

      对于变量申明限定符部分，可能有类型限定符，还可能有非类型限定符(例如：static , extern , virtual)。类型限定符只直接作用于申明体(申明的变量)的类型；而非类型限定符直接作用于申明体。
      继续拿前面的例子，x是一个数组，unsigned long int是类型限定符，表示x这个数组的元素类型；而static是非类型限定符，指示x是静态分配内存。

观点4：

        对于观点3，非类型限定符主要是针对static来说的，对于const 和volatile来说，它们是类型限定符。
        举个例子：const void *vectortable[N]

        如果把const当作非类型限定符的话，按照观点3来分析，vectortable是一个数组，const由于是非类型限定符，所以是修饰vectortable的，于是vectortable是一个指向数组的常量指针，数组元素的类型是void *。事实上不是这样，const是类型限定符，修饰变量vectortable的类型的，这样vectortable是一个指向数组的指针，数组元素类型是const void *。

观点5：

        限定部分的各个限定词之间的前后顺序没关系。
        例如：const   VP   t;   和 VP const T等价

                 const char   *p 等价于 char const   *p;

        说明：大多数资料和程序员都习惯将static非类型限定符放在变量申明的最前面，实际上这仅仅是习惯的问题，并不是语言自身的规定。

观点6：

        一种申明风格：对于限定部分里面的各个类型限定词，如果有const ，最好把const 放在右边而不是左边。尽量使用 T const 代替 const T，避免错误。

        例如：const   char *p; 我们这样写： char const *p。之所以这样做，是为了可读性。注意这个可读性是针对人的，而不是针对编译器的。前面观点5说了，编译器不区分这个顺序。下面我们看看这样书写风格怎样达到可读性好的效果。

T const *p : 从右往左读(*作为分隔符，标记指针的)：p是指针，指向const T；

等价于：const T *p;

T * const p : 从右往左，常量指针指向T

由上可见方便之处了。我们只要按照从右往左边顺序就可以读出来申明的意义。

除此之外，这样写还不会出错。我们看看下面的一个例子。

typedef int *IP;

int a = 3;

const IP t = &a;

此时t是啥类型呢？

按照以前风格，我们替换IP为 int * 得到：const int * t；如此一来，等价于int const * t;也就是说t是指向常整形指针。实际上是否是这样的呢？

答案是否定的。实际上t是指向整形的常指针。正确的理解是代替IP用如下方式：

const    IP    t

int    *const t;

因此，在申明变量的时候，将const放在限定部分的最右边是一种比较好的做法。例如上面对变量t的申明：IP const t；这样保证程序员不会对t的类型产生误解。

注意：如果你非要使用typedef来实现const int   *t，那么就直接typedef const int *CIP；然后：CIP   t;就可以了。

-----------------------------------------------------------------------------------------------------

       1. 不能再赋值

        const int i=5;
 　　int j=0;
 　　...
 　　i=j; //非法，导致编译错误
 　　j=i; //合法
 　　2. 必须初始化
 　　const int i=5; //合法
 　　const int j; //非法，导致编译错误
 　　3. 在另一连接文件中引用const常量
 　　extern const int i; //合法
 　　extern const int j=10; //非法，常量不可以被再次赋值
 　　4. 便于进行类型检查
 　　用const方法可以使编译器对处理内容有更多了解。
 　　#define I=10
 　　const long &i=10; /*dapingguo提醒：由于编译器的优化，使
 　　得在const long i=10; 时i不被分配内存，而是已10直接代入
 　　以后的引用中，以致在以后的代码中没有错误，为达到说教效
 　　果，特别地用&i明确地给出了i的内存分配。不过一旦你关闭所
 　　有优化措施，即使const long i=10;也会引起后面的编译错误。*/
 　　char h=I; //没有错
 　　char h=i; //编译警告，可能由于数的截短带来错误赋值。
 　　5. 可以避免不必要的内存分配
 　　#define STRING "abcdefghijklmn/n"
 　　const char string[]="abcdefghijklm/n";
 　　...
 　　printf(STRING); //为STRING分配了第一次内存
 　　printf(string); //为string一次分配了内存，以后不再分配
 　　...
 　　printf(STRING); //为STRING分配了第二次内存
 　　printf(string);
 　　...
 　　由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，
 　　而不是象#define一样给出的是立即数，所以，const定义的常量在
 　　程序运行过程中只有一份拷贝，而#define定义的常量在内存中有
 　　若干个拷贝。
 　　6. 可以通过函数对常量进行初始化
 　　int value();
 　　const int i=value();
 　　dapingguo说：假定对ROM编写程序时，由于目标代码的不可改写，
 　　本语句将会无效，不过可以变通一下：
 　　const int &i=value();
 　　只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其
 　　值有不会被修改。
 　　7. 是不是const的常量值一定不可以被修改呢？
 　　观察以下一段代码：
 　　const int i=0;
 　　int *p=(int*)&i;
 　　p=100;
 　　通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。
 　　8. 请分清数值常量和指针常量，以下声明颇为玩味：
 　　int ii=0;
 　　const int i=0; //i是常量，i的值不会被修改
 　　const int *p1i=&i; //指针p1i所指内容是常量，可以不初始化
 　　int * const p2i=ⅈ //指针p2i是常量，所指内容可修改
 　　const int * const p3i=&i; //指针p3i是常量，所指内容也是常量
 　　p1i=ⅈ //合法
 　　*p2i=100; //合法