​1.常量成员 const

类的常量成员，具备以下特性：

1.1.const成员必须被初始化

1.2.const成员只能在初始化列表中赋值

1.3.const成员不能在构造函数原型中赋值

1.4.const成员初始化之后无法更改

class ConstMember
{
public:
    ConstMember(int num = 0) 
        :m_num(num)        //ok,对应1、2，否则无法通过编译
    {
        //m_num = num;    //error，对应3，只能在初始化列表内赋值
    }
    ~ConstMember() {} ;
    void set(int num = 0) {
        //m_num = num;    //error，对应4，const变量无法被更改
    }
    const int getNum() { return m_num; }
private:
    const int m_num;
};

int main(){
    ConstMember c1;
    cout << "c1 = " << c1.getNum() << endl;    // 输出0
    ConstMember c2(2);
    cout << "c2 = " << c2.getNum() << endl;    // 输出2
    c1.set(3);    //无法被更改，否则会报错
    cout << "c1 = " << c1.getNum() << endl;    // 输出0
    return 0;
}

2.静态成员 static

类的静态成员，具备以下特性：

2.1.static成员必须被初始化，只能在类的外面进行初始化，且不能带static关键字

2.2.static成员不能在初始化列表中初始化

2.3.static成员可以在构造函数原型中被更改

2.4.static成员可以被外部更改

2.5.static成员被所有的此类共享，在某个类中改变其数值，会影响其它同类当中的该成员数值

class StaticMember
{
public:
    StaticMember(int num = 0)
        //:m_num(num)    //error，对应2，不能在初始化列表赋值
    {
        m_num = num;    //ok，对应3，可以在构造函数内赋值
    }
    ~StaticMember() {} ;
    void set(int num = 0) {
        m_num = num;    //ok，对应4，可以改变值
    }
    const int getNum() { return m_num; }
private:
    static int m_num;
};

int StaticMember::m_num = 0;    //对应1，必须在外部赋值

int main(){
    StaticMember s1;
    cout << "s1 = " << s1.getNum() << endl;    // 输出0
    StaticMember s2(2);
    cout << "s2 = " << s2.getNum() << endl;    // 输出2
    s1.set(3);
    cout << "s1 = " << s1.getNum() << endl;    // 输出3
    cout << "s2 = " << s2.getNum() << endl;    // 输出3，对应5，改变s1当中的静态变量，导致s2中的也发生改变
    return 0;
}

3.静态常量成员 static const

类的静态常量成员，具备以下特性：

1.static const成员必须被初始化，只能在类的外面进行初始化，且不能带static关键字，必须带const关键字

2.static const成员不能在初始化列表中初始化

3.static const成员不可以在构造函数原型中被更改

4.static const成员不可以被外部更改

5.static const成员被所有的此类共享

class StaticConstMember
{
public:
    StaticConstMember(int num = 0)
        //:m_num(num)    //error，对应2，不能在初始化列表赋值
    {
        //m_num = num;    //error，对应3，不能在构造函数内
    }
    ~StaticConstMember() {} ;
    void set(int num = 0) {
        //m_num = num;    //error，对应4，不能更改值
    }
    const int getNum() { return m_num; }
private:
    static const int m_num;
};

const int StaticConstMember::m_num = 0;    //对应1，在外部初始化

int main(){
    StaticConstMember sc1;
    cout << "sc1 = " << sc1.getNum() << endl;    // 输出0
    StaticConstMember sc2(2);
    cout << "sc2 = " << sc2.getNum() << endl;    // 输出0，共享静态变量，且无法修改，因此不改变值
    sc1.set(3);
    cout << "sc1 = " << sc1.getNum() << endl;    // 输出0，共享静态变量，且无法修改，因此不改变值
    cout << "sc2 = " << sc2.getNum() << endl;    // 输出0，共享静态变量，且无法修改，因此不改变值
    return 0;
}

4.静态成员函数

静态成员函数包含以下特性：

1.静态成员函数可以不构造类，直接调用

调用方式为 类名::函数名。

2.静态成员函数不能包含内部任何形式的非静态成员

3.静态成员函数可以接受外部参数

4.静态成员函数可以包含内部静态成员

class StaticFunction {
public:
    static void Helloworld() {
        cout << "Hello world" << endl;
    }
    static void SetValue(int a) {    //参考4，可以接受外部参数
        //m_s = m_i;    //error，参考2，不能包含任何非静态成员
        //m_s = m_c;    //error，参考2，不能包含任何非静态成员
        m_s = 4;    //参考3，可以包含非静态成员
        m_s = a;    
    }
private:
    int m_i;
    const int m_c;
    static int m_s;
};

int StaticFunction::m_s = 1;

int main(){
    StaticFunction::Helloworld();    //参考1，无需构造类，直接调用
    StaticFunction::SetValue(2);
    return 0;
}