C++ 中 const 和 static 关键字（定义，用途）

C++ 中 const 和 static 关键字（定义，用途）

1、static 定义及用途

static 作用： 控制变量的存储方式 和 可见性

1、修饰局部变量：

通常局部变量在程序中存放栈区，局部的生命周期在包含语句块执行完时便会结束，使用 static 关键字对局部变量修饰后，变量会存放静态数据区，其生命周期会延续到整个程序结束。

但是作用域没有改变，作用域还是限制在其他语句块中。

个人理解： static 修饰局部变量，可认为是 延长变量生命周期的局部变量（不会随着函数结束而是放）

void demo()
{
	//函数结束会被释放
	int a = 10;
	//static 修饰局部变量 ，不会被释放
	static int b = 20;
}

2、修饰全局变量：

static 对全局变量修饰改变作用域范围，由普通全局变量的整个工程可见，变为本文件可见。

//普通全局变量 作用域整个工程文件 ，其他源文件访问 通过 extern 关键字声明
int d = 40;

//只能作用于 当前文件
static int c = 30;

3、修饰函数：

和全局变量一样 ，改变作用域，限制在本文件使用。

4、修饰类 ：

对类中某函数修饰，表示该函数属于一个类，而不是此类的任何对象 ；

对类中某一个变量修饰 ， 便是该变量为所有对象所有，存储空间中只有一个副本，可以通 过 类 和 对象 调用（该变量类内声明，类外初始化）

class Person
{
public:
	Person(string name,int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
  //静态函数
   	static void func()
	{
		//m_age = 50;   静态函数只能访问静态变量
		m_score = 99;
		cout << m_score << endl;
	}
  
	string m_name;
	int m_age;
   //静态成员变量   类内声明
	static int m_score; 
};

int Person::m_score = 100; //静态变量 类外初始化

int main()
{
	Person p1("张三" , 18);
	Person p2("李四", 20);

	cout << "成绩 " << p1.m_score << endl; //通过类对象访问
	p2.m_score = 80; //静态变量 只有一个副本，一个内存空间
	cout<< "成绩 " << p2.m_score << endl; 
  
  //静态函数调用
	Person::func();    // 通过类调用
	p1.func();         //通过类对象调用
 
	return 0;
}

2、const 定义及用途

const 作用：限制可读性

1、const修饰基础数据类型

const 在基础数据类型前、后 结果一样，在使用这些常量的时候不能改变常量的值

const int Max = 100;
int const Min = 1;

void demo()
{
	//Max = 110; 常量不可修改
	//Min = 2;   常量只读性
	cout << Max << Min << endl;
}

2、修饰指针变量 和 引用变量

如果const 在 * 左侧 ，则const修饰指针所指向的变量 ，即指针指向常量

如果const 在 * 右侧 ，则const修饰指针本身 ，即指针本身为常量

int a = 10, b = 20;

//使 指针指向常量   (指针指向可改 ，指向的值不可以更改)
const int* p1 = &a;  
p1 = &b;
//*p1 = 100;              错误用法

 //使 指针本身为常量  （指针指向不可改 ，指向的值可以更改）
int* const p2 = &b; 
//p2 = &a;              错误用法
*p2 = 100;

3、const 修饰普通函数

• const修饰函数参数

防止传入的参数在函数体内被改变,但仅对指针、应用有意义。因为如果是按值传递，传给参数的仅仅是实参的副本，即使在函数体内改变了形参，实参也不会得到影响。如：

void func(const int i)
{
	//i = 10;  不能修改i
	cout << i << endl;
}

const修饰的函数参数是指针时,代表 在函数体内不能修改该指针所指的内容，起到保护作用

void fun(const char * src, char * des)
{  
  //保护源字符串不被修改，若修改src则编译出错。
	strcpy(des,src);
}

• const 修饰函数返回值

用const来修饰返回的指针或引用，保护指针指向的内容或引用的内容不被修改

//const 修饰函数返回值 
const int* getNum(int* a)
{
	return a;
}

int a = 10;
auto ret= getNum(&a);
//ret = 20  返回值不能修改

4、const 在类中的用法

const 修饰成员函数

在成员函数后添加 const 为这个函数为 常函数

常函数 不可修改成员属性；

成员属性声明时加关键字mutable后，在常函数中依然可以修改；

常对象：

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数

class Person
{
public:
	Person(string name,int age)
	{
		this->m_name = name;
		this->m_age = age;
	}

	//常函数
	void func() const
	{
		m_sore = 100;

	}
	//普通成员函数
	void Print()
	{
		cout << "姓名： " << this->m_name << "  年纪:" << this->m_age << end;
	}
	string m_name;
	int m_age;
	mutable int m_sore =60;  //特殊变量
};

int main()
{
	const Person p("张三", 18);  // 常对象

	//常对象调用常函数
	p.func();
	//p.Print();  常对象只能调用常函数
	
	p.m_sore = 160;   //m_sore 为特殊变量只能在常对象下修改
	cout << p.m_sore << endl;

	system("pause");
	return 0;
}