C语言日记 19 局部变量（和全局变量），​​​​​​​变量的生存期和存储类别

局部变量

书P70：

（5）在函数声明中出现的参数名，其作用范围只在本行的括号内。

实际上，系统会忽略函数声明中的变量名，即使在调用函数时也不会为它们分配存储单元。

书上举例：

int max(int a, int b);    //函数声明中出现 a、b
...
int max(int x, int y)
{
    cout << x << endl<< y << endl;    //合法，x、y在函数体中有效
    cout << a << b << endl;//非法，a、b 在函数体中无效
}

本例（这里）说明：

声明中出现的参数名，在函数定义区域内没有（不起）作用。

例：

1.

#include <iostream>
using namespace std;
int main()
{
    int max(int a, int b);
    a = 8, b = 5;
}
int max(int x, int y)
{
    cout << x << endl << y << endl;
}

结果：
 

本例（这里）说明：

声明中出现的参数名，不仅在函数定义区域内没有（不起）作用

在函数声明括号外的区域也没有（不起）作用。

2.

#include <iostream>
using namespace std;
int main()
{
    int max(int a = 5, int b = 8);
    cout << max(a, b) << endl;
}
int max(int x, int y)
{
    cout << x << endl << y << endl;    
    return 0;
}

结果：

本例（这里）说明：

声明中出现的参数名

不仅在函数定义区域内没有（不起）作用

在函数声明括号外的区域也没有（不起）作用

而且哪怕是在声明时赋的值，在后面后续的语句当中也不起作用

变量的生存期存储类别

1.自动变量（auto）：  形参，函数中定义的变量

2.静态变量（static）：

 例4-11

静态局部变量的值。

源程序：

#include <iostream>
using namespace std;
int f(int a)//定义 ￡(）函数，a为形参
{
    int b = 0;//定义b为自动变量
    static int c = 3;//定义c为静态局部变量
    b = b + 1;
    c = c + 1;
    return a + b + c;
}
int main()
{
    int a = 2, i;
    for (i = 0; i < 3; i++)
        cout << f(a) << " ";
    cout << endl;
    return 0;
}

#include <iostream>
using namespace std;
int f(int a)//定义 ￡(）函数，a为形参
{
	int b = 0;//定义b为自动变量
	static int c = 3;//定义c为静态局部变量
	b = b + 1;
	c = c + 1;
	return a + b + c;
}
int main()
{
	int a = 2, i;
	for (i = 0; i < 3; i++)
		cout << f(a) << " ";
	cout << endl;
	return 0;
}

结果：

程序运行流程：

关于静态变量的关键字（当然也包括后面动态变量的关键字）的具体使用方式和使用范围，我们在此作如下介绍：

PROJECT 1:

关于静态变量的关键字（当然也包括后面动态变量的关键字）的具体使用方式和使用范围，我们在此作如下介绍：

第一种：如同后面C语言日记 26 指针与函数_宇 -Yu的博客-CSDN博客的例6-8一样：

#include <iostream>
using namespace std;
int f(int a)//定义 ￡(）函数，a为形参
{
	static int c = 3;int i = 1;
	i = i + 1;
	return i;
}
int main()
{
	int a = 2, i;
	for (i = 0; i < 3; i++)
		cout << f(a) << " ";
	cout << endl;
	return 0;
}

此时的输出结果：

自然的，从这个结果里面我们容易得到（结论）：

此时只有c是静态变量，i不是。

注意：此时（需要的，是）：

当输出结果一直不变：

说明在程序每进行完（结束）一轮循环（以后），都会进行一次清除缓存的操作（即原来函数中（里）的c和i在本轮循环结束，下轮开始之前都没有值）

而此时我们清楚地知道：

当程序清缓存时，说明被清除的那些变量是动态变量不是静态变量

也就是说此时i是动态变量，至于c我们前面声明过，自然知道他是静态变量

第二种：

     static int c = 3; i = 1;

实际上是事实上根本不存在第二种这样形式输出的式子

我们根本无需考虑这种形式的语句里面的i是否为静态变量，因为这样的语句直接会报错数出不了：

或者

     static int c = 3，int i = 1;

也一样，语法错误直接废了

第三种：

#include <iostream>
using namespace std;
int f(int a)//定义 ￡(）函数，a为形参
{
	static int c = 3, i = 1;
	i = i + 1;
	return i;
}
int main()
{
	int a = 2, i;
	for (i = 0; i < 3; i++)
		cout << f(a) << " ";
	cout << endl;
	return 0;
}

 此时的输出结果：

同样自然的，从这里我们容易得到（结论）：

此时c和i都是静态变量；因为同样的：

当程序清缓存时，说明被清除的那些变量是动态变量不是静态变量

而此时c和i都没有被清

PROJECT 2:

第一种：如同后面C语言日记 26 指针与函数_宇 -Yu的博客-CSDN博客的例6-8一样：

#include <iostream>
using namespace std;
int f(int a)//定义 ￡(）函数，a为形参
{
	static int c = 3; int b = 0;
	b = b + 1;
	c = c + 1;
	return a + b + c;
}
int main()
{
	int a = 2, i;
	for (i = 0; i < 3; i++)
		cout << f(a) << " ";
	cout << endl;
	return 0;
}

此时的输出结果和上面一样：7 8 9；（语句其实也都一样，自然结果输出的都一样）

自然的，从这个结果里面我们容易得到（结论）：

此时只有c是静态变量，b不是。

第二种：

     static int c = 3; b = 1;

实际上是事实上根本不存在第二种这样形式输出的式子

我们根本无需考虑这种形式的语句里面的i是否为静态变量，因为这样的语句直接会报错数出不了：

而同理（同样的）：

    static int c = 3,int b = 0; 

结果：

第三种：

#include <iostream>
using namespace std;
int f(int a)//定义 ￡(）函数，a为形参
{
	static int c = 3, b = 0;
	b = b + 1;
	c = c + 1;
	return a + b + c;
}
int main()
{
	int a = 2, i;
	for (i = 0; i < 3; i++)
		cout << f(a) << " ";
	cout << endl;
	return 0;
}

 此时的输出结果：

同样自然的，从这里我们容易得到（结论）：

此时c和b都是静态变量。（每一轮循环结束都可以（能够）保留在上一轮循环原有的值）

3.寄存器变量

4.外部变量 

例4-12 用extern对外部变量作提前引用声明，以扩展程序文件中的作用域

源程序：

#include <iostream>
using namespace std;
int max(int, int);
void main()
{
	extern int a, b;//对全局变量 a、b作提前引用声明
	cout << max(a, b) << endl;
}
int a = 15, b = -7;//定义全局变量a、b
int max(int x, int y)
{
	int z;
	z = x > y ? x : y;
	return z;
}

#include <iostream>
using namespace std;
int max(int, int);
void main()
{
    extern int a, b;//对全局变量 a、b作提前引用声明
    cout << max(a, b) << endl;
}
int a = 15, b = -7;//定义全局变量a、b
int max(int x, int y)
{
    int z;
    z = x > y ? x : y;
    return z;
}

结果：

书P75：

一般都把全局变量的定义放在引用它的所有函数之前，这样可以避免在函数中多加一个extern声

明。

这里所说的“把全局变量的定义放在引用它的所有函数之前”

我觉得未必有一点混淆和累赘了，准确的来说，我们这里不妨把他简单粗暴地记为：

如果我们要定义一个全局变量（后面在不同的函数里要反复使用调用）那我们不妨把他们全部简单粗暴地定义（规定）为在函数开头声明（#include <iostream>  using namespace std;后面就声明），例如：（这里）

#include <iostream>
using namespace std;
int max(int, int);
extern int a, b;//对全局变量 a、b作提前引用声明
void main()
{
    cout << max(a, b) << endl;
}
int a = 15, b = -7;//定义全局变量a、b
int max(int x, int y)
{
    int z;
    z = x > y ? x : y;
    return z;
}

#include <iostream>
using namespace std;
int max(int, int);
extern int a, b;//对全局变量 a、b作提前引用声明
void main()
{
    cout << max(a, b) << endl;
}
int a = 15, b = -7;//定义全局变量a、b
int max(int x, int y)
{
    int z;
    z = x > y ? x : y;
    return z;
}

结果不变

对于全局变量（外部变量），我想在这里补充强调一点显而易见但是非常重要，如果理不灵清会非常麻烦的一个点：（书P76也有）

不管是不是静态外部变量（全局变量）的全局变量，他们都是静态变量

也就是说：

他们在函数调用结束以后并不释放（清空）而是始终保留原值。（随着前面函数改变全局变量的值会影响后续这个全局变量的值）   

例4-13 外部变量的使用。
 
源程序：

file1.cpp 
extern int a, b;
int main()
{
    cout << a << "," << b << endl;
    return 0;
}
file2.cpp 
    int a,b;
    a = 3; b = 4;

file1.cpp 
extern int a, b;
int main()
{
    cout << a << "," << b << endl;
    return 0;
}
file2.cpp 
    int a,b;
    a = 3; b = 4;

静态全局变量（外部变量）举例：

file1.cpp
static int a = 3;
int main()
{
    ...
}
file2.cpp
extern int a;
int fun(int n)
{
    ...
    a = a * n;
    ...
}

file1.cpp
static int a = 3;
int main()
{
	...
}
file2.cpp
extern int a;
int fun(int n)
{
	...
	a = a * n;
	...
}