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

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

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

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

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

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

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

数据类型	初始化默认值
int	0
char	‘\0’
float	0
double	0
pointer	NULL

2.存储类说明符

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

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

3.static 修饰局部变量

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

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

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

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

编译运行：

~/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

4.extern 存储类

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

support.cpp:

#include 
using namespace std;

int count; // 全局变量

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

main.cpp:

#include 
using namespace std;

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

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

编译运行：

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

5.mutable

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

编译运行：

~/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

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

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