【C++】const和static修饰成员的情况

const

1、const修饰成员变量

class Test
{
public:
	Test(int a, int b):
		ma(a),mb(b)//初始化列表
	{
	}
private:
	const int ma;//声明常成员变量
	int mb;
};
int main()
{
	return 0;
}

2、const修饰对象

class Test
{
public:
	Test(int a, int b):
		ma(a),mb(b)//初始化列表
	{
	}
	void Show()
	{
		std::cout << "ma" << ma << std::endl;
		std::cout << "mb" << mb << std::endl;
	}
private:
	int ma;//声明常成员变量
	int mb;
};
int main()
{
	Test test(10,20);
	test.Show();
	return 0;
}

对象中的成员是不可修改的
3、const修饰常函数
我们将Test test(10,20);改为const Test test(10,20);，此时的const修饰的就是一个常对象，然后常对象调用show函数，我们发现调用失败：

程序出错的原因：

• 对于普通的类成员方法来说都是thiscall调用约定，show函数就会有隐藏的参数：void Show(Test* const this)
• 这个隐藏的参数是系统提供的。所以在调用的时候程序第一步会将test对象的地址传递给this指针:Test* const this = &test;

 Test test(10,20);
	test.Show();

这两步现在就相当于：

const Test test(10,20);
Test const this = &test;

第一句的const修饰的是test，间接访问也就是*this
第二局的const修饰的是this
这样就会有间接访问修改常量的风险
可以改为：

const Test test(10,20);
const Test const this = &test;

在代码中的修改为：在函数的原型后面加const

void Show()const
	{
		std::cout << "ma" << ma << std::endl;
		std::cout << "mb" << mb << std::endl;
	}

这样程序就是正确的：

const修饰常函数就是修饰函数内部的this指针，也就是将Type* const this转变为const Type* const this
常对象是不能调用普通方法
常对象只能调用常方法

static

1、static修饰变量
普通的成员变量是属于对象
静态成员变量不属于对象所有对象共享
静态的成员变量不依赖对象访问
一定要在类外初始化

class Test
{
public:
	Test( int b):
	mb(b)//初始化列表
	{
	}
private:
	static int ma;//声明常成员变量
	int mb;
};
int Test::ma = 10;//静态成员变量的初始化方式
int main()
{
	Test test1(10);
	Test test2(20);
	Test test3(30);
	test1.ma = 100;
	std::cout << test2.ma << std::endl;
	return 0;
}

类外实现成员方法

class Test
{
public:
	Test(int b, int c);
	void Show();
private:
	static int ma;
	int mb;
	int mc;
};
Test::Test(int b, int c)
:mb(b),mc(c)
{
}
void Test::Show()
{
	std::cout << "ma:" << ma << std::endl;
	std::cout << "mb:" << mb << std::endl;
	std::cout << "mc:" << mc << std::endl;
}
int Test::ma = 10;
int main()
{
	Test test(10,20);
	test.Show();
	return 0;
}

2、static修饰成员方法
静态的成员方法是_cdecl调用约定，没有this指针
静态的成员方法可以访问静态的成员变量

int gdata = 10;
class Test
{
public:
	Test(int b, int c);
	static void Show();
	{
		std::cout << "ma:" << ma << std::endl;
		std::cout << "gata:" << gata << std::endl;
	}
private:
	static int ma;
	int mb;
	int mc;
};
Test::Test(int b, int c)
:mb(b),mc(c)
{
}
int Test::ma = 10;
int main()
{
	Test test(10,20);
	test.Show();
	return 0;
}

静态的成员方法不能调用普通的成员方法
普通的成员方法可以调用静态的成员方法

int gdata = 10;
class Test
{
public:
	Test(int b, int c);
	static void Show();
	{
		std::cout << "ma:" << ma << std::endl;
		std::cout << "gata:" << gata << std::endl;
	}
	void Print()
	{
		std::cout << "mb:" << mb << std::endl;
		std::cout << "mc:" << mc << std::endl;
		Show();
		//this->Show();//通过对象的方式调用
		//Test::Show();//通过作用域的方式调用
	}
private:
	static int ma;
	int mb;
	int mc;
};
Test::Test(int b, int c)
:mb(b),mc(c)
{
}
int Test::ma = 10;
int main()
{
	Test test(10,20);
	test.Show();
	return 0;
}