const ,static,inline

const:

1 定义变量 ，如下写法都可以：

TYPE const ValueName = value;
                 const TYPE ValueName = value;

2 当作为全局变量并且在他文件也想使用时：（默认const具有局部性）

1.CPP  ：extern const TYPE ValueName = value;定义

2.CPP：  extern const  TYPE ValueName; 外部声明

上面两个const 和TYPE可以颠倒。

3 指针使用const

如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
         如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。

4 函数参数中返回值中用const

5 类与const：
    class A
    {
        …
        const int nValue;        //成员常量不能被修改
        …
        A(int x): nValue(x) { } ; //只能在初始化列表中赋值

void function()const; //常成员函数, 它不改变对象的成员变量.

//也不能调用类中任何非const成员函数。

}

1)修饰成员变量：表示成员常量，不能被修改，同时它只能在初始化列表中赋值。

2）const成员函数不被允许修改它所在对象的任何一个数据成员，函数中可以使用非const成员变量，但不能修改。 不能调用类中任何非const成员函数。（因为任何非const成员函数会有修改成员变量的企图。）const成员函数声明和定义const都不能少

3）const类对象、指针、引用：只能调用类的const成员函数，可以使用成员变量，但不能改变值。因此，const修饰成员函数的最重要作用就是限制对于const对象的使用。

class A
{
public:
   const int nValue;        //成员常量不能被修改
   int m_a;

   A(int x,int a): nValue(x) { m_a=a;} ; //只能在初始化列表中赋值

   void func()const; //常成员函数, 它不改变对象的成员变量.                       

    //也不能调用类中任何非const成员函数。
}; 

void A::func() const
{
    cout<<m_a<<endl;
    cout<<nValue<<endl;
}
int main()
{
    const A aa(,);
    cout<<aa.m_a<<endl;
    aa.func();
    return ;
}

补充：const与宏区别：

#define PI 3.14159         //常量宏
const doulbe  Pi=3.14159;  //此时并未将Pi放入ROM中
              ......
double i=Pi;   //此时为Pi分配内存，以后不再分配！
double I=PI;  //编译期间进行宏替换，分配内存
double j=Pi;  //没有内存分配
double J=PI;  //再进行宏替换，又一次分配内存！

static:

class MyTestClass
{
    public:
        MyTestClass() : m_ciInt(), m_csStr("MyStr")  // const成员变量，在ctor参数列表中初始化
            {}
    public:
        const int m_ciInt;
        const string m_csStr;
        static int m_siInt;
        static string m_ssStr;
        const static int m_csiInt;
        const static string m_cssStr; 

        static void func();
};
    int MyTestClass::m_siInt = ; // static成员变量，在外部定义
    string MyTestClass::m_ssStr = "MyStr"; // static成员变量，在外部定义
    const int MyTestClass::m_csiInt = ;  // const static/static const成员变量，在外部定义
    const string MyTestClass::m_cssStr = "MyStr"; // const static/static const成员变量，在外部定义

     void MyTestClass::func()
    {
        cout<<m_siInt<<m_ssStr<<m_csiInt<<m_cssStr<<endl;
    }
    int main()
    {
        MyTestClass myclass;
        myclass.func();
        MyTestClass::func();
        return ;

    }

一般这么初始化就可以了，高版本编译器支持类声明中 const static int m_csiInt=5;//常量声明式。

通常C++要求你对所使用的任何东西提供一个定义式，但如果是类的const static 且为整数类型（int，char,bool）
则可以“in_class初值设定”。只要后续使用中不取它们的地址，就可以这么声明后无需提供定义式。如果需要定义式，在类外：

const int MyTestClass::m_csiInt;//不可以再设初值。

注意：static成员变量外部定义不可以出现static关键字。

静态变量和静态函数存在的意义？

答：类中静态函数意义：（类外定义不能写static关键字）

1静态私有成员在类外不能被访问，可通过类的静态成员函数来访问；

2 当类的构造函数是私有的时，不像普通类那样实例化自己，只能通过静态成员函数来调用构造函数。（单例模式）

普通静态函数，静态变量作用：限定了只能在本文件中使用。

静态成员变量和静态成员函数都是为类所拥有，只有一份。静态变量保存在静态存储区。

inline：C++类中使用

三种内联函数形式：1 默认内联函数 2 显示定义内联函数 3 类外定义为内联函数

class Student
{
  private:
    int nID
int
nAge;
    float fScore;
  public:
    void setID(int nid){ nID = nid; }    //该成员函数默认自动为内联函数(隐式定义内联函数)
    inline void setAge(int nage) { nAge = nage; }   //显式定义内联函数
    void setScore(float fscore);         //类定义体内没有声明为内联函数;
}
inline void Student::setScore(float fscore){ fScore = fscore; } //类定义体外实现为内联函数;

由于内联函数是编译器在便宜阶段进行函数体展开的，所以，这就把类的内联函数的定义与实现都必须在声明类的那个头文件中，而不能放在实现类的那个cpp文件中；这一点与模板template<>的特性相似；