黑马程序员——C语言日志——static和extern

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、static和extern修饰局部变量
1、static对局部变量的作用
1)延长局部变量的生命周期，从程序启动退出，但是并没有改变变量的作用域。
2)定义变量的代码在整个程序运行期间仅仅会执行一次。看下面的两段代码，分别用static修饰一个局部变量count和不用static修饰局部变量的情况对比一下

#include "stdlib.h"
void fun()
{
	static int count=0;           //使用static修饰局部变量count
	printf("count=%d\n",count);  //打印count值
	count++;
}
int main(){

        fun();                        //第一次调用fun()，打印count=0，之后count++
	fun();                        //第二次调用fun()，打印count=1，之后count++
	fun();                        //第二次调用fun()，打印count=2，之后count++
    system("pause");                  //DOS窗口停留  
}

打印结果：count=0
          count=1
          count=2

#include"stdio.h"
#include "stdlib.h"
void fun()
{
	int count=0;           //不使用static修饰局部变量count
	printf("count=%d\n",count);  //打印count值
	count++;
}
int main(){

    fun();                            //第一次调用fun()，打印count=0，之后count++
	fun();                        //第二次调用fun()，打印count=1，之后count++
	fun();                        //第二次调用fun()，打印count=2，之后count++
    system("pause");                  //DOS窗口停留  
}

打印结果：count=0
          count=0
          count=0
通过以上两段代码，就能很清楚的说明static的作用了。使用static修饰过的count在第二次fun()被调用的时候，并不是初始化的值0，而是++之后的值1，即说明了上述static在修饰局部变量中的两点


作用。还有一点需要说明的是，static修饰的变量和全局变量一样，如果没有初始化，其值默认为0，即程序中：
static int count=0;  //等价于static int count；
2、extern对局部变量的作用
extern并不能修饰局部变量。
二、static和extern修饰全局变量
全局变量分为：1)内部变量：只能在本文件中访问的变量。
               2)外部变量：可以在其他文件中访问的变量，默认所有全局变量都是外部变量。
1、static修饰全局变量的作用
1)声明一个内部变量和定义一个内部变量，由于静态局部变量的作用于限于一个源文件内，只能为该源文件使用，因此可以避免在其他文件中引起错误。
2)static修饰过的全局变量在其他文件中可以同名。
我们建立一个工程，分别创建main.c、test.c和test.h三个文件，代码如下：

/****main.c******/
#include"stdio.h"
#include "stdlib.h"
#include"test.h"
int count=7;                       //在main.c源文件中定义全局变量count
void main(){
   
     printf("count=%d\n",count);  //打印count值 
     test();                     
    system("pause");              //DOS窗口停留  
}

/****test.c******/
#include"test.h"
static int count=5;       //在test.c源文件中定义一个静态全局变量count
void test()
{
	printf("count=%d",count);
}

/****test.h******/
#include"stdio.h"
void test();                 //声明函数test()

程序运行结果：count=7
              count=5
所以，static修饰的count只能在自己所在文件内使用，和main中的count互不影响。如果test.c中的count没有static修饰，那么程序编译会报错为：count重复定义，即有两个同名的全局变量。
  
2、extern修饰全局变量的作用
extern修饰的全局变量，表示当前变量不仅可以在本文件中使用，也可以在其他文件中使用。
注意：extern修饰的全局变量在不同的文件中不能同名（两个文件必须有包含关系）。如果头文件中没有声明该变量，也可以在当前文件中声明。
我们举例仍然使用上面的工程：

/****main.c******/
#include"stdio.h"
#include "stdlib.h"
#include"test.h"
extern int count;                       //在main.c源文件中声明全局变量count，引用其他文件中定义的变量
void main(){
  // extern int count;                 //此处也可以声明全局变量
     printf("count=%d\n",count);  //打印count值 
     test();                     
    system("pause");              //DOS窗口停留  
}

/****test.c******/
#include"test.h"
 int count=5;       //在test.c源文件中定义一个全局变量count
void test()
{
	printf("count=%d",count);
}

/****test.h******/
#include"stdio.h" 
//extern int count;               //在test.h头文件中也可以声明全局变量count
void test();                 //声明函数test()

程序打印结果：
count=5
count=5
就是说，我们在test.c中定义了一个变量count，而在main,c中使用这个变量，那么就用extern修饰这个变量，即声明变量，就可以在main.c文件中使用这个在其他文件中的变量了。
三、static和extern修饰函数
先看两个概念：内部函数和外部函数。假设有A,B两个文件，内部函数：在A文件中定义的函数，在A文件中访问。外部函数：在B文件中访问在A文件中定义的函数，该函数在B文件中称为外部函数。
1、static修饰的函数是内部函数，只能在定义的那个文件中使用。
比如，我们在test.c中定义一个内部函数：

/****test.c******/
#include"test.h"
 int count=5;       //在test.c源文件中定义一个全局变量count
static void test()
{
	printf("count=%d",count);
}

在test.h中声明

/****test.h******/
#include"stdio.h" 
//extern int count;               //在test.h头文件中也可以声明全局变量count
static void test();                 //声明函数test()

那么我们在主函数中去调用这个test()函数

/****main.c******/
#include"stdio.h"
#include "stdlib.h"
#include"test.h"
extern int count;                       //在main.c源文件中声明全局变量count，引用其他文件中定义的变量
void main(){
  
     printf("count=%d\n",count);  //打印count值 
     test();                     
    system("pause");              //DOS窗口停留  
}

程序报错，说没有定义test()函数，所以用static修饰过的函数，不能被其他文件中函数调用。
如果我们在test.c文件中再定义另一个函数fun()：

/****test.c******/
#include"test.h"
 int count=5;       //在test.c源文件中定义一个全局变量count
static void test()
{
	printf("count=%d",count);
}
void fun()                              //用这个函数调用test()
{ 
  printf("fun调用test()内部函数\n"); 
  test();

}

/**在test.h中声明***/
/****test.h******/
#include"stdio.h" 
static void test();                 //声明函数test()
void fun();                        //声明函数fun()

我们在主函数中去调用这个fun()函数

/****main.c******/
#include"stdio.h"
#include "stdlib.h"
#include"test.h"
extern int count;                       //在main.c源文件中声明全局变量count，引用其他文件中定义的变量
void main(){
     printf("count=%d\n",count);  //打印count值 
     fun();                     
    system("pause");              //DOS窗口停留  
}

这样调用运行成功，说明static修饰的函数只能被本文件中函数调用。
2、extern声明的函数，可以在本文件中使用，也可以在其他文件中使用。（有没有使用extern都可以在其他文件中使用）
同样是上面的工程，我们将函数test.c中的函数test()用extern修饰：

/****test.c******/
#include"test.h"
 int count=5;       //在test.c源文件中定义一个全局变量count
extern void test()      //用extern修饰函数
{
	printf("count=%d",count);
}

我们在主函数中仍然能够成功调用，所以，extern在修饰函数上不起什么作用。