C++全局变量与局部变量初始化的问题及存储类修饰符

一般来说，C++ 有三个地方可以声明变量：

1. 在函数或一个代码块内部声明的变量，称为局部变量。
2. 在函数参数的定义中声明的变量，称为形式参数。
3. 在所有函数外部声明的变量，称为全局变量。

从上面的定义来看C++全局变量与局部变量就很好区分了。局部变量只能被函数内部或者代码块内部的语句使用，而全局变量的值在程序的整个生命周期内都是有效的。全局变量可以被任何函数访问，在整个程序中都是可用的。

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。

1.局部变量和全局变量的初始化

局部变量和全局变量的初始化是有区别的。当局部变量被定义时，系统不会对其初始化，必须自行对其初始化。定义全局变量时，系统会自动初始化为下列值：

2.存储类说明符

这些说明符放置在它们所修饰的类型之前，用于定义 C++ 程序中变量/函数的范围（可见性）和生命周期：

• auto：auto 存储类是所有局部变量默认的存储类
• register：register 存储类用于定义存储在寄存器中而不是内存中的局部变量。
• static：static 存储类指示编译器在程序的生命周期内保持局部变量的存在
• extern：extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。
• mutable：仅适用于类的对象，它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

3.static 修饰局部变量

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

#include <iostream>
using namespace std;

// 函数声明
void func(void);
// 全局变量
static int count = 10;
int main(){ while(count--){ func(); } return 0;
}
void func(){ static int i = 5; // 局部静态变量 i++; cout << "i = " << i << endl; cout << "count = " << count << endl;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
 

编译运行：

~/Desktop/c++$ g++ example02.cpp -o example02
~/Desktop/c++$ ./example02
i = 6	count = 9
i = 7	count = 8
i = 8	count = 7
i = 9	count = 6
i = 10	count = 5
i = 11	count = 4
i = 12	count = 3
i = 13	count = 2
i = 14	count = 1
i = 15	count = 0


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
 

4.extern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当使用 ‘extern’ 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。可以在文件中使用 extern 来得到在其他文件中已定义的变量或函数的引用。

support.cpp:

#include <iostream>
using namespace std;

int count; // 全局变量

void func_extern(){ cout << "count is " << count << endl;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
 

main.cpp:

#include <iostream>
using namespace std;

extern int count;// 使用support.cpp文件中定义的count全局变量
extern void func_extern();// 使用support.cpp文件中定义的函数

int main(){ count = 5; func_extern(); return 0;
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

编译运行：

~/Desktop/c++$ g++ support.cpp main.cpp -o main
~/Desktop/c++$ chmod 754 main
~/Desktop/c++$ ./main
count is 5

  

 

  
1
  
2
  
3
  
4
 

5.mutable

#include <iostream>
#include <string.h>
using namespace std;

class Customer{ private: char name[25]; char order[50]; int tableNumber; mutable int bill; public: Customer(const char* s,const char *m,int a,int b){ strcpy(name,s); strcpy(order,m); tableNumber = a; bill = b; } void changeBill(int s) const{ // 如果bill不是mutable修饰的话，修改bill就是非法的 bill = s; } void display() const{ cout << "name:" << name << endl; cout << "order:" << order << endl; cout << "tableNumber:" << tableNumber << endl; cout << "bill:" << bill << endl; }
};

int main(){ // const 修饰了Customer，那么c1就只能调用const修饰的函数,否则，怎么调都行 const Customer c1("Tom","Burger",3,100); c1.display(); c1.changeBill(34); c1.display(); return 0;
} 
  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
 

编译运行：

~/Desktop/c++$ g++ mutable.cpp -o mutable
~/Desktop/c++$ ./mutable
name:Tom
order:Burger
tableNumber:3
bill:100
name:Tom
order:Burger
tableNumber:3
bill:34

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
 

const Customer c1("Tom","Burger",3,100);这一句将c1变量声明为常量，说明c1初始化后，就不能再修改，c1调用任何非const函数都会报异常。如果调用const函数中，修改了非mutable变量，也会报异常。

mutable的使用场景就是让const对象中的变量，也可以通过const函数修改。如果一个客户订餐，名字和台号是不能改变，但是订单bill会随着点餐的变化而变化，也就是一个对象有些变量不能改变，有些变量需要改变。mutable就应运而生了。

文章来源: blog.csdn.net，作者：WongKyunban，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/weixin_40763897/article/details/111682968