存储类型、作用域、可见性和生存期C++
第十五章 存储类型、作用域、可见性和生存期
15.1 存储类型
15.1.1 外部存储
15.1.2 静态存储类型
15.2 作用域和可见性
15.2.1 局部作用域
15.2.2 全局作用域 和 域操作符
15.2.3 作用域嵌套及可见性
15.3 生存期
15.3.1 程序的内存分区
15.3.2 动态生存期
15.3.3 局部生存期
15.3.4 静态生存期
15.3.5 局部静态变量
15.4 对前15章的一点小结
上一章我们讲了“程序的文件结构”。主要涉及到一个问题，即：A文件中定义的某个变量，如果在B文件也能使用它。其间我们学到一个新关键字：extern，它用来声明一个变量，并且指明这是一个“外来的”的变量。如果你对我说的这些感到陌生，那么你先复习一下上一章。
这一章，我们正是要从extern说起。
15.1 存储类型
存储类型分“外部存储”和“静态存储”两种。
15.1.1 外部存储
外部存储类型使用 extern 关键字表示。
上一章我们其实一直在用外部存储类型的变量。
一个全局变量或函数，如果你需要在其它源文件中可以共用到，那么你必须将它声明为“外部存储类型”。这其实就是上一章我们所讲的内容。这里再举个例子，简要复述一次。
在A.cpp 文件中，有一个全局变量 a,和一个函数： func();
//A.cpp 文件：
...
int a;
void func()
{
...
}
...
我们希望在B.cpp 或更多其它文件可以使用到变量a和函数func(),必须在“合适的位置”声明二者：
//B.cpp 文件：
...
extern int a; //a 由另一源文件(A.cpp)定义
extern void func(); //func 由另一源文件(A.cpp)定义
a = 100;
func();
...
这里例子中，“合适的位置”是在B.cpp文件里。其它合适的位置，比如在头文件里的例子，请复习上一章。
另外一点需要得强调一次：函数的定义默认就是外部的,所以上面 func()之前的extern也可以省略。
在使用extern 声明全局变量或函数时，一定要注意：所声明的变量或函数必须在，且仅在一个源文件中实现定义。
如果你的程序声明了一个外部变量，但却没有在任何源文件中定义它，程序将可以通编译，但无法链接通过。下面是该错误类型的一个例子，大家请打开CB，将下面代码写入完整的一个控制台工程。
错误一、只有声明，没有定义：
1、用CB新建一个空白控制台工程，CB将自动生成Unit1.cpp。加入以下黑体部分：
extern void func2();
int main(int argc, char* argv[])
{
func2();
return 0;
}
2、新建一个单元文件(菜单：New | Unit)：Unit2.cpp。在Unit2.cpp后面加入：
extern int a; //a 由另一源文件(A.cpp)定义
extern void func(); //func 由另一源文件(A.cpp)定义
void func2()
{
a = 100;
func();
}
现在按Ctrl + F9，将出现以下错误：
[Linker Error] 表明这是一个“链接”错误。两个错误分别是说变量a和函数func()没有定义。
（你可能奇怪为什么错误消息里，变量'a'的名字变成了'_a'？这是编译器遵循某些标准，在编译结果上对变量名做了一些改变，我们不必理会）
请大家想一想，并试一试，如何解决这两个链接错误。
错误二、有声明，但重复定义
1、用CB新建一个空白控制台工程，CB将自动生成Unit1.cpp。加入以下黑体部分：
extern void func2();
int a; // <--全局变量a在此定义了一次
void func() // <--函数func()在此定义了一次
{
a = 20;
}
int main(int argc, char* argv[])
{
func2();
return 0;
}
2、和错误一的第2步完全一样：
extern int a; //a 由另一源文件(A.cpp)定义
extern void func(); //func 由另一源文件(A.cpp)定义
void func2()
{
a = 100;
func();
}
3、再新建一个单元文件：Unit3.cpp，在文件后加入：
int a; // <--全局变量a在此又定义了一次
void func() // <--函数func()在此又定义了一次
{
a = 20;
}
现在编译这个含有三个单元文件的工程。这回答的是一个链接“警告/Warning”：
警告很长，无非是说全局变量 'a' 在两个模块内重复定义。 对了，func()函数我们不是也重复定义了吗？为什么没有得到警告？这是因为CB对重复定义的函数，将只取其一，然后自动抛弃所有重复项。下面的操作可以看到这一结果。
既然是错误类型只是“警告”，那就是说我们可以硬下心肠不管，继续运行。我们现在来看看，两个func()函数，CB到底用了哪一个？
这里需要在运行前，在两个func()的函数定义处，都设置断点：
第一个断点：在Unit1.cpp 文件里：
第二个断点：在Unit3.cpp 文件里：
然后按F9，运行，我们看到断点停在 Unit1.cpp中的 func()定义上：
而另一处：Unit3.cpp 里的断点，变“黄”（无效断点）了：
之所以成为无效断点，有两种原因：
其一是某些代码，比如单纯的变量声明：int a; 或如宏定义等，这些代码在编译后成为程序的初始化部分，无需运行。
其二是某些无用，或可优化的代码中编译过程被丢弃。
这里正是第二种情况。
尽管变量或函数重复定义似乎并不造成“致命”错误，但我们同样需要严加注意，消除所有这类错误。请大家对本例进行改错。
15.1.2 静态存储类型
静态存储类型使用 static 关键字表示。
static 关键限定其所修饰的全局变量或函数只能在当前源文件中使用。
反过来说，如果我们确定某个全局变量仅仅是在当前源文件中使用，我们可以限定它为静态存储类型。
static 的使用格式 ：
static 变量定义或函数定义
如：
static int a;
static void func();
举一个例子，下面的代码可以正确编译、运行：
Unit1.cpp 文件：
...
extern int a;
int main(int argc, char* argv[])
{
a = 100;
return 0;
}
Unit2.cpp 文件：
...
int a;
说明：在Unit1.cpp 文件中用到了外部变量：a, a在Unit2.cpp文件内定义。
现在，我们要限定 Unit2.cpp 里的变量 a 只能在 Unit2.cpp 内可以使用：
Unit2.cpp 文件：
...
static int a;
我们为 a 的定义加了一个修饰：static。现在再编译，编译器提示一个链接错误，我们在本章前面说过的：“变量 a 没有定义”：
静态函数的例子类似：
Unit1.cpp 文件：
...
void func();
int main(int argc, char* argv[])
{
func();
return 0;
}
Unit2.cpp 文件：
int i;
static void func()
{
i = 100;
}
按Ctrl+F9，得到以下链接错误：
又是两个制造错误例子，不要偷懒，务必亲手制造出这两个错误，并且再改正后，才继续看下面的课程。千万不要仅满足于“看得懂”就不动手。那样绝对不可能学会编程。
static 还有一种用法,称为函数局部静态变量，作用和这里的“全局静态”关系不大，我们在后面的“生存期”中会讲到。
由于静态变量或静态函数只在当前文件（定义它的文件）中有效，所以我们完全可以在多个文件中，定义两个或多个同名的静态变量或函数。
比如在A文件和B文件中分别定义两个静态变量a：
A文件中：
static int a;
B文件中：
static int a;
这两个变量完全独立，之间没有任何关系，占用各自的内存地址。你在A文件中改a的值，不会影响B文件中那个a的值。
15.2 作用域和可见性
作用域和可见性可以说是对一个问题的两种角度的思考。
“域”，就是范围；而“作用”，应理解为“起作用”，也可称为“有效”。所以作用域就是讲一个变量或函数在代码中起作用的范围，或者说，一个变量或函数的“有效范围”。打个比方，就像枪发出的子弹，有一定的射程，出了这个射程，就是出了子弹的“有效”范围,这颗子弹就失去了作用。
代码中的变量或函数，有的可以在整个程序中的所有范围内起作用，这称为“全局”的变量或函数。而有的只能在一定的范围内起作用，称为“局部”变量。
15.2.1 局部作用域
我们在 5.1.3 “如何为变量命名”这一小节中讲到： “不能在同一作用范围内有同名变量”。因此，下面的代码是错误的：
...
int a; //第一次定义a
int b;
b = 2*a;
int a; //错误：又定义了一次a
...
那么，在什么情况下，变量属于不同的作用范围呢？我们这里说的是第一种：一对{}括起来的代码范围，属于一个局部作用域。如果这个局部作用域包含更小的子作用域，那么子作用域的具有较高的优先级。在一个局部作用域内，变量或函数从其声明或定义的位置开始，一直作用到该作用域结束为止。
例一：变量只在其作用域内有效
void func()
{
int a;
a = 100;
cout << a << endl; //输出a的值
}
int main(int argc, char* argv[])
{
cout << a << endl; // <-- 错误： 变量a未定义
return 0;
}
说明：在函数 func()中，我们定义了变量a，但这个变量的“作用域”在 } 之前停止。所以，出了花括号以后，变量a就不存在了。请看图示：
结论：在局部作用域内定义的变量，其有效范围从它定义的行开始，一直到该局部作用域结束。
在局部作用域内定义的变量，称为“局部变量”。
上例中的局部作用域是一个函数。其它什么地方我们还能用到{}呢？很多，所有使用到复合语句的地方，比如：
//if 语句
if( i> j)
{
int a;
... ...
}
上面的a是一个局部变量，处在的if语句所带的那对 {} 之内。
//for 语句：
for(int i=0;i<100;i++)
{
int a;
... ...
}
上面的a也是一个局部变量。处在for语句带的{}之内。
for 语句涉及局部作用域时，有一点需要特别注意：上面代码中，变量 i 的作用域是什么？
根据最新的 ANSI C++ 规定，在for的初始语句中声明的变量，其作用范围是从它定义的位置开始，一直到for所带语句的作用域结束。而原来老的标准是出了for语句仍然有效，直到for语句外层的局部作用域结束。请看对比：
假设有一for语句，它的外层是一个函数。新老标准规定的不同作用域对比如下：
如果按照旧标准，下面的代码将有错，但对新标准，则是正确的，请大家考虑为什么：
void func()
{
for(int i=0;i<9;i++)
{
cout << i << endl;
}
for(int i=9;i>0;i--) //<-- 在这一行，旧标准的编译器将报错，为什么?
{
cout << i << endl;
}
}
Borland C++ Builder 对新旧标准都可支持，只需通过工程中的编译设置来设置采用何种标准。默认总是采用新标准。记住：如果你在代码中偶尔有需要旧标准要求的效果，你只需把代码码写成这样：
int i;
for(i=0;i<9;i++)
{
...
}
这时候，i的作用域就将从其定义行开始，一直越过整个for语句。
其它还有不少能用到复合语句（一对{}所括起的语句组）的流程控制语句，如do..while等。请复习以前相关课程。
其实，就算没有流程控制语句，我们也可以根据需要，在代码中直接加上一对{}，人为地制造一个“局部作用域”。比如在某个函数中：
void func()
{
int a = 100;
cout << a << endl;
{
int a = 200;
cout << a << endl;
}
cout << a << endl;
}
代码中红色部分即是我们制造的一个局部作用域。执行该函数，将有如下输出：
100
200
100
你能理解吗？
15.2.2 全局作用域 和 域操作符
如果一个变量声明或定义不在任何局部作用域之内，该变量称为全局变量。同样，一个函数声明不处于任何局部作用域内，则该函数是全局函数。
一个全局变量从它声明或定义的行起，将一起直接作用到源文件的结束。
请看下例：
//设有文件 Unit1.cpp,内定义一个全局变量：
int a = 100;
void func()
{
cout << a << endl;
}
输出：
100
我们今天还要学习到一个新的操作符，域操作符 “::”。域操作符也称“名字空间操作符”，由于我们还没学到“名字空间”，所以这里重点在于它在全局作用域上的使用方法。
:: 域操作符，它要求编译器将其所修饰的变量或函数看成全局的。反过来说，当编译器遇到一个使用::修饰的变量或函数时，编译器仅从全局的范围内查找该变量的定义。
下面讲到作用域的嵌套时，你可以进一步理解全局作用域如何起作用，同时，下例也是我们实例演示如何使用域作用符::的好地方。
15.2.3 作用域嵌套及可见性
例二：嵌套的两个作用域
在例一的基础上，我增加一个全局变量：
int a = 0; //<-- 全局变量,并且初始化为0
void func()
{
int a;
a = 100;
cout << a << endl; //输出a的值
}
int main(int argc, char* argv[])
{
cout << a << endl; //输出a的值
}
我们在 5.1.3 “如何为变量命名”这一小节中讲到： “不能在同一作用范围内有同名变量”。 上面的代码中，定义了两个a，但并不违反这一规则。因为二者处于不同的作用范围内。下图标明了两个a的不同作用范围：
从图示中看到：两个变量a：1个为全局变量，一个为局部变量。前者的作用域包含了后者的作用域。这称为作用域的嵌套。
如果在多层的作用域里，有变量同名，那么内层的变量起作用，而外层的同名变量暂时失去作用。比如在上例中，当代码执行到①处时，所输出的是函数 func()内的a。而代码②处，输出的是全局变量a。
这就引出一个“可见性”这个词，当内层的变量和外层的变量同名时，在内层里，外层的变量暂时地失去了可见性。
不过，如果外层是全局作用域，那么我们可以使用::操作符来让它在内层有同名变量的情况下，仍然可见。
int a = 0;
void func()
{
int a;
a = 100;
cout << a << endl; //输出内层的a；
cout << ::a << endl; //输出全局的a。
}
最后请大家把本节中讲到例子，都在CB上实例际演练一下。
15.3 生存期
一个变量为什么有会不同的作用域？其中一种最常见的原因就是它有一定的生存期。什么叫生存期？就像人一样，在活着的时候，可以“起作用”，死了以后，就不存在了，一了百了。
那么，在什么情况下一个变量是“活”着，又在什么情况下它是“死”了，或“不存在”了呢？
大家知道，变量是要占用内存的。比哪一个int类型的变量占用4个字节的内存，或一个char类型的变量占用1个字节的内存。如果这个变量还占用着内存，那么我们就认为它是“活着”，即，它存在着。而一个变量释放了它所占用的内存，我们就认为它“死了”，“不存在”了。
有哪个同学能告诉我，在我们的教程中，我这是第几次讲到“变量和内存”的关系？呵，我也记不得了。不管怎样，这里又是一次——我们必须从整体上讲一讲：一个程序在内存中如何存放？
15.3.1 程序的内存分区
先从程序上看“生”和“死”。
用CB编译出一个可执行文件(.exe)，它被存放在磁盘上。当它没有运行时，我们认为它是“死”的。而当我们双击它，让它“跑”起来时，我们认为它是“活”的，有了“生命”。等我们关闭它，或它自行运行结束，它又回到了“死”的状态下。在这个过程里。
程序运行时，它会从操作系统那里分得一块内存。然后程序就会把这些内存（严格讲是内存的地址）进行划分，哪里到哪里用来作什么。这有点像我们从老板那里领来2000大洋，其中1000无要交月租，500元做生活费……真惨。
那么，程序有哪些需要入占用内存呢？
首先，代码需要一个空间来存放。因此，到手的内存首先要分出一块放代码的地方，称为代码区。剩下的是数据。根据不同需要，存放数据有区域有三种：数据区，栈区，堆区。为什么存放数据的内存需要分成三个区域？这个我先不说，先来说说数据（变量等）被放入不同的区内，将遇上什么样不同的命运。
第一、放入数据区的数据。
生存期：这些数据的命运最好。它们拥有和程序一样长的生存期。程序运行时，它们就被分配了内存，然后就死死占着，直到程序结束。
谁负责生死：这些数据如何产生，如何释放，都是程序自动完成的，我们程序员不用去费心为产生或释放这些变量写代码。
占用内存的大小：这些数据都必须有已知，且固定的大小，比如一个int变量，大小是4个字节，一个char类型，大小是1个字节。为什么必须这样？因为如果这个数据可以占用的大小是未定的，那么，程序就不可能为自动分配内存。
初始化：就是这个变量最开始的值是什么？放在数据区里的数据，可以是程序员用代码初始化，比如：
int a = 100;
这样，a的值按你意思去办，并初始化为100；但如果你没有写初始的代码，如：
int a;
那么，数据区内的数据将被初始化为全是0。
第二、放入堆区的数据。
生存期：堆内的数据什么时候“生（分配内存）”，什么时候“死（释放内存）”，由程序员决定。
谁负责生死：当然就是程序员了。C++里，有专门的函数或操作符来为堆里的变量分配或释放内存。程序员通过写这些代码来在需要时，让某个堆里的变量“生”，不需要时，让它“死”。
占用内存的大小：堆里的数据占用的内存可以是固定的，也可以是可变的。这就是C,C++里最强大也最难学的内容：“指针”所要做事。
初始化：由程序员完成。如果程序员不给它初始值，则它的值是未定的。
由于程序员掌握着堆区内的数据的“生死大权”，并且决定着该数据占用多少内存。所以在写程序时，必须特别注意这些数据。一不小心就会出错。比如一个数据还没有分配内存呢，你就要使用它，就会出错。更常见的是，一个数据，你为它分配了内存，可是却始终没有为替它释放内存，那样就会造成“内存泄漏”。就算你的程序都退出了，这个数据依然可能“阴魂不散”地占用着内存。
第三、放入栈区的数据。
生存期：对比前面的两种，数据区里数据具有永久的生存期，而堆里的数据的生存期算是“临时”的。需要了，程序员写代码产生；不需要了，又由程序员写代码释放。在程序员，临时才需要变量非常多，如果每个变量都由程序员来负责产生、释放，那程序员岂不很累？并且很危险（万一忘了释放哪个大块头的家伙....)。所以，必须有一种机制可以让程序自已来产生和释放某些临时变量。所以，放入堆区的数据是只有程序员才能决定的何时需要，何时不需的临时数据，而栈区数据则是编译器就能决定是否需要的临时数据。 当然，要想让编译器能知道数据什么时候需要，什么时候不需要，就必须做一种约定。这正是我们现在讲的“生存期”的语法内容。
谁负责生死：程序（和数据区的一样）。
占用内存的大小：固定大小（和数据区的一样）。
初始化：由程序员完成。如果程序员不给它初始值，则它的值是未定的(和堆区的一样)。
下面是三个区加上代码区的分布示意图：
现在，我们也比较好回答前面的问题：“为什么存放数据的内存需要分成三个区域”?原因正在于程序所要用到的数据具有不同的生存期要求，所以编译器把它们分别放到不同空间，好方便实现要求。
生存期和作用域的关系是：如果一个变量已经没有了生存期，那么自然它也就没了有作用域。但反过来，如果一个变量出了它的作用域，它并不一定就失去了生存期。典型的如函数内的静态数据，下面会讲到。
15.3.2 动态生存期
就是放在“堆区”的数据。这些数据是在程序运行到某一处时，由程序员写的代码动态产生；后面又由程序员写的代码进行释放。我们现在还没有学习如何为变量（指针变量）分配和释放的内存的知识。
15.3.3 局部生存期
这里的局部和前面讲“局部作用域”一致，都是指“一对{}括起来的代码范围”。
请看下面代码，并思考问题：
//从前，有一个函数……
void func()
{
//函数内，有一个局部变量……
int a;
cout << a << endl;
a = 100;
}
//看清楚了，上面输出 a 的值的语句， 位于给a赋值之前！
//然后，下面的代码是两次调用这个函数：
...
func();
func();
...
第一次调用，我们知道屏幕肯定是要输出一个莫名其妙的数，因未初始化的局部变量，其值是不定的。我们以前讲变量时，就做过实例。现在，这里的变量a被输出后，我们让赋于它100。再接下来，我们又调用了一次函数func();请问这回输出的值，是100呢？或者仍然是莫名其妙的数？
大家打开CB，把这个例子做做。注意，动手生成一个空白的控制台工程后，调用func()的那两行代码，要放到主函数main()内，形如：
……
int main(int argc, char* argv[])
{
func();
func();
……
}
正确答案应该是：“仍然是莫名其妙的数”。尽管在第一次调用时func()时，局部变量最后被赋值为100；但很可惜，出了函数这个作用域，a 立即就死掉了……第二次再调用函数func()时，那个像个a投胎转世的婴儿，一切又重新开始……它又是一个没有被赋值的的变量了。
请大家把本例中的变量a改为全局变量，并且在函数func()的定义之前定义。再试一试。
15.3.4 静态生存期
就是放在“数据区”里的数据。程序一运行时，它们就开始存在；程序结束后，它们自动消亡。
这里讲的“静态”，和前面的“静态存储类型”不是一个意思。（老师，我忘了什么叫“静态存储类型”？呵，这有可能，本章的内容互相都有些关联和相似，大家多看几遍本章，最主要是课程让你动手的地儿，你就动手做，正所谓“该出手时就出手手……”）。
“静态存储类型”是指：一个全局变量，它被加上static之后，就只能在本文件内使用，别的文件不能通过加extern的声明来使用它。
“静态生存期“是指：一个变量，它仅仅产生和消亡一次（即在程序运行时产生，在程序退时消亡），而不像“动态生存期”或“局部生存期”那样可以生生死死，不断“投胎转世”。
下面的代码演示了“静态生存期”和“局部生存期”变量的不同。请你看完以后，回答问题。
#include <iostream.h>
//定义，声明一个全局变量：
int a;
//声明一个函数,定义在后面
void func();
int main(int argc, char* argv[])
{
int b = 100;
a = 10;
cout << a << end;
cout << b << end;
//调用函数func：
func();
}
//func()的定义：
void func()
{
cout << a << endl;
cout << b << endl;
}
哪里有错呢？请大家想想，试试。
15.3.5 局部静态变量
//从前，有一个函数……
void func()
{
//函数内，有一个局部变量……
int a;
cout << a << endl;
a = 100;
}
//调用两次：
func();
func();
同样是这个例子，我们只是要把 int a 之前加上一个 static 关键字：
void func()
{
//函数内，有一个局部静态变量……
static int a;
cout << a << endl;
a = 100;
}
...
func();
func();
...
我们要问的也是同样一个问题：第二次调用 func()后，输出的 a 值是多少？
这回答案是：输出的值是100。
这就是局部静态变量的特殊之处：尽管出了函数的作用域之后，变量已经不可见，并且也失去了作用。但是，它仍然存在着！并且保留着它最后的值。因此，它也是静态生存期。它也只在程序结束之后，才失去生存期。
上面讲的是局部静态变量“死”的问题，它也只“死”一次，对应地，显然它也只能“生”一次。
void func()
{
static int a = 30; //在定义时，同时初始化该局部静态变量为30。
cout << a << endl;
a = 100;
}
...
func();
func();
...
这回要问的是第一次调用func()时，输出的是什么？第二次呢？
答案：第一次输出30，第二次输出100，以后若有第三次，第四次，也是输出100。这就是说，初始化：static int = 30；这一句，仅被执行一次！
好，假如代码是这样子呢?
void func()
{
static int a;
a = 30; //改成不是在定义时同时初始化
cout << a << endl;
a = 100;
}
...
func();
func();
...
请回答我，这回，两次调用func()分别输出什么？
有关内存的堆、栈内容，最近我曾在CSDN上做过回答。大家如有兴趣，不妨去看看。（别忘了，我叫“nanyu”）。要学习编程，CSDN是不错的地方。大家有空常去(最好注册个ID)。我因为太忙，去不了几次。
http://expert.csdn.net/Expert/topic/1255/1255577.xml?temp=.1724665
15.4 对前15章的一点小结
一般教材用6或7章的内容，我们扩展成15章。大家可能嫌我讲得太慢。这我承认。哎，我的事情太多了。特别是最近这一段时间，先是笔者得了肾结石，剧痛了一夜最后住入医院，接着是我的宝宝发高烧，我在医院里守了一宿，未料到我的爱人接着也 得上医院……可恨的是电信局里不知哪个家伙一时兴起，来个什么“改线”，改来改去也不知改错了什么，我的ASDL就一断数天……幸好我天天打电话免费（不，是倒贴电话费 啊）为他们培训什么叫ADSL。（其实我也不懂，不过我总得旁敲侧击地暗示他们，“你们是不是动了什么啊？好好想想？再想想？”，哎，总的来说，他们的客户服务态度还是很好的……）。
不管怎样，在此我向所有付费报名的学员致歉。
这15章的内容，属于C,C++的基础知识，其中有些更是基础中基础。从第16章（数组）开始，就开始中级或高级的内容了。这些新的内容都有一个特点：都和内存地址有着千丝万缕的关系。所以大家有时间抓紧把前面的都复习中，其中犹其是要把我讲到的，有关“变量和内存”关系，全部重新消化一遍。
明天就是冬至了。圣诞节即到，在此我向大家问个节日快乐，并感谢早早给我发来贺卡的几位同学。
更重要的是春节即将到来，但愿我们能在春节前学完C++。然后一起向更为精彩的 Windows编程世界出发。