C语言和c++中的static关键字与const关键字
static： //改变存储区域，限制作用域
①、改变存储区域：
在不同的上下文中，static 关键字可以用于改变变量或函数的存储区域。在函数内部，static 用于将局部变量的生存期从函数的生命周期扩展到整个程序的生命周期，并将其存储在静态存储区中。
示例：
void foo() {
static int count = 0; // 静态局部变量
count++;
std::cout << "Count: " << count << std::endl;
}
int main() {
foo(); // 输出：Count: 1
foo(); // 输出：Count: 2
return 0;
}
②、限制作用域：
static 还可以用于限制变量、函数或类的作用域，使其仅在声明它们的文件中可见，而不是跨越整个程序的多个文件。这种情况下，static 在全局变量、函数和类的上下文中使用。
示例：
Copy code
// File1.cpp
static int globalVar = 42; // 在当前文件中可见
// File2.cpp
extern int globalVar; // 从另一个文件中访问失败，因为 globalVar 的作用域被限制在了 File1.cpp 中
在这个示例中，globalVar 被声明为静态全局变量，它的作用域限制在了声明它的文件 File1.cpp 中，其他文件无法直接访问。
一、C和c++中的static
static
1、修饰局部变量 //改变存储区域： 栈区–>数据段 ，作用域：局部作用域
②C语言中static修饰的局部变量：
在修饰局部变量时，static修饰的静态局部变量只执行一次， 其会改变局部变量的存储位置，从而使得局部变量的生命周期变长，直到程序运行结束以后才释放。
void test()
{
int x = 0;
x++;
printf("%d ", x);
}
int main()
{
int i = 0;
while (i < 5)
{
test();
i++;
}
return 0;
}
//1 1 1 1 1
void test()
{
static int x = 0;
x++;
printf("%d ", x);
}
int main()
{
int i = 0;
while (i < 5)
{
test();
i++;
}
return 0;
}
//1 2 3 4 5
②c++中static修饰的局部变量：
局部变量也就是定义在函数内部的变量，函数局部变量存放在栈区，该变量的生命周期由所在 {} 决定，进入 {} 作用范围而分配内存空间，退出 {} 作用范围而释放内存空间。
在局部变量的前面加上static，变成静态局部变量，即使多次调用该函数，静态变量的空间也只分配一次。
using namespace std;
void fun()
{
static int n = 5;
printf("%d\n", n);
n++;
}
int main()
{
int i;
for(i=0; i<5; i++)
{
fun();
}
return 0;
}
2、修饰全局变量 //限制作用域：外部链接属性–>内部链接属性
①C语言中的static修饰的全局变量
static修饰全局变量的时， 会改变全局变量的链接属性，从而使得全局变量作用域变为只能在本文件中访问，extern无法调用。
c文件1
int i = 10;
c文件2
extern int i;
int main()
{
printf("%d\n",i);
return 0;
}
如果全局变量被static修饰，那这个外部链接属性就会被修改成内部链接属性
②c++中static修饰的全局变量
全局变量的空间会在程序的生命周期内分配，在全局变量的前面加上static，变成静态全局变量。
using namespace std;
static int n = 5;
int main()
{
n = 10;
printf("%d\n", n);
return 0;
}
3、修饰函数 //限制作用域：外部链接属性–>内部链接属性
①C语言中static修饰函数
static修饰一个函数，则这个函数的只能在本文件中调用，不能被其他文件调用。
函数本身也是有外部链接属性的,而被static修饰后，函数的外部链接属性被修改成内部链接属性。
c文件1
int Add(int a,int b)
{
return x+y;
}
c文件2
extern int Add(int a,int b);
int main()
{
int x = 3;
int y = 4;
int z = Add(x,y);
printf("%d\n",z);
return 0;
}
②c++中的static修饰函数
被static修饰的函数，叫静态函数。静态函数只能在当前文件中被访问，不可再其他文件中调用。其它文件中可以定义相同名字的函数，不会发生冲突
4、在c++中static还可以修饰成员变量 ：静态成员变量， //不用通过对象调用， 所有对象共有的变量，
类的所有实体共享这个变量。
类的数据成员在类外定义时不加static。
class Test {
public:
double d;
static int n;
};
int Test::n; // 静态成员变量需要在类外声明(分配空间，可以显式初始化，默认初始化为0)
cout << sizeof(Test) << endl;
cout << Test::n << endl;
// 运行结果：8 0
静态成员变量存储在全局/静态区，静态成员变量只有在类外声明时才分配空间，可显式初始化，不显式初始化，默认初始化为0。
静态成员变量属于类不属于对象，sizeof()的结果不包括静态成员变量大小
可通过对象调用，也可以通过类名作用域调用(非静态成员变量只能通过对象调用)
静态常量整型数据成员可在类内初始化，也可在类外初始化
5、在c++中static还可以修饰成员函数: 静态成员函数，静态方法 //不用通过对象调用
静态成员函数中只能调用静态成员变量和静态成员函数
类的静态成员函数在类外实现时，与数据成员一样不需要加 static
class Test {
public:
static void show() {
cout << n << endl;
}
private:
double d;
static int n;
};
int Test::n;
cout << sizeof(Test) << endl;
Test::show();
// 运行结果：8 0
二、C和c++中的const
const:
const含义：只要一个变量前用const来修饰，就意味着该变量里的时数据只能被访问，而不能被修改，也就是意味着“只读”（readonly）
const在类中既可以修饰成员变量，也可以修饰成员函数本身，甚至还能修饰对象。
const作用：
1：可以用来修饰变量，修饰函数参数，修饰函数返回值，且被const修饰的东西，都受到强制保护，可以预防其它代码无意识的进行修改，从而提高了程序的健壮性
2：使编译器保护那些不希望被修改的参数，防止无意代码的修改
3：增强代码的可读性
1、修饰变量
此时变量只能使用不可修改，直接修改（编译报错）与修改地址（程序异常）都不行
int main() {
const int a = 20 ;
printf("a = %d\n",a);
a = 200 ;//err
printf("a = %d\n",a);
return 0;
}
2、修饰指针变量类型（常量指针）
const修饰指针变量的类型，不可修改指针指向的地址里的内容（编译报错），可以修改指针的指向
void test()
{
int c = 100;
const int *p = &c;
printf("c = %d\n",c);
//*p = 888;//不可修改指针指向的地址里的内容，编译报错
//printf("c = %d\n",c);
int d =999;
p = &d;//可以修改指针的指向
printf("*p = %d\n",*p);
}
int main(int argc, char *argv[])
{
test();
return 0;
}
3、修饰指针变量(指针常量)
可以修改指针指向地址的内容，但是不能修改指针的指向（编译报错）
void test()
{
int c = 200;
int * const p = &c;//const修饰指针，即指针常量
printf("*p = %d\n",*p);
*p = 888;//修改指针指向地址里的内容
printf("*p = %d\n",*p);
int d =999;
//p = &d;//不能修改指针的指向，编译报错
//printf("*p = %d\n",*p);
}
int main(int argc, char *argv[])
{
test();
return 0 ;
}
4、既修饰指针变量类型又修饰指针（常量指针常量）
不能修改指针指向地址的内容，不能修改指针指向
void test()
{
int c = 200;
const int * const p = &c;//即修饰指针变量类型又修饰指针变量
printf("*p = %d\n",*p);
//*p = 888;//不能修改指针指向地址里的内容，编译报错
//printf("*p = %d\n",*p);
//int d =999;
//p = &d;//不能修改指针指向，编译报错
//printf("*p = %d\n",*p);
}
int main(int argc, char *argv[])
{
test();
return 0;
}
5、修饰函数返回值
如果给以“指针传递”方式的函数返回值加 const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加 const 修饰的同类型指针。
const char * GetString(void);
//如下语句将出现编译错误：
//char *str = GetString();
//正确的用法是
const char *str = GetString();
6、修饰函数参数
如果函数参数采用“指针传递”，那么加 const 修饰可以防止意外地改动该指针，起到保护作用。
如果参数作为输出参数，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加 const 修饰，否则该参数将失去输出功能（因为有 const 修饰之后，不能改变他的值）。
如果参数作为输入参数，可以防止数据被改变，起到保护作用，增加程序的健壮性。
7、修饰类中的变量与函数
<1>修饰成员变量
对成员变量的修饰与修饰普通变量差不多，都是设置为只读数据，但是类中的const变量
只能 通过构造函数初始化列表进行初始化 或者 直接值，
using namespace std;
class A
{
public:
A(int a):m_a(a){
} //正常
A(int a){
//报错
m_a = a;
}
private:
const int m_a; //成员变量 只读 const变量
};
int main()
{
A A1(1);
}
<2>修饰成员函数
首先，const修饰成员函数，保留了const修饰普通函数的用法；其次，增加了在成员函数的声明后边添加const的用法，表示成员函数内部无法修改成员变量。
using namespace std;
class A {
public:
int a = 1;
/*
第一个const：表示返回指针指向不可被更改
第二个const：参照const修饰变量的用法
第三个const：表示该成员函数不可修改成员变量
*/
void show(const int* p) const ; //修饰函数 cosnt函数 ： 函数不能修改变量
};
void A::show(const int* p) const {
a = 2;//报错，被第三个const限制
*p = 2;//报错，被第二个const限制
cout<<"a="<<a<<endl;
cout<<"*p="<<*p<<endl;
}
int main(){
A a;
int c = 2;
const int *b = &c;
b = a.show(b);
*b = &c;//报错，被第一个const限制
}
<3>修饰对象 类似于修饰变量
在实例化对象的时候，添加const关键字，就是const对象，const对象只能访问类中的const成员变量和const成员函数。
const class object(params);
const class *p = new class(params); //两种用法等价