C++类成员：const 和 static用法

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;
}