问题引出原因：
 
        在一个头文件a.h中定义一些变量x，在其他.c文件中(b.c，c.c)要用到，在两个*.c中包含a.h以后，
        编译时总是提示error:multiple definition of x。
 
解决思路：
 
        当时本想采用extern变量的方法，但考虑到会使用sizeof() 计算extern数组的大小，因此无法使用extern，最后只能采用static的方法，原因如下。
 
外部变量extern
 
        把所有的全局变量放入一个头文件 global.h，每一个变量前面加extern，声明一下这些变量将在其它文件中定义。 然后建立一个和头文件名字对应的.c or .cpp文件 如global.c。在里面声明所有的全局变量。例如：void(*Handl_Display)();
 然后，让涉及到全局变量的文件include ”global.h“。这样编译时，会先对global.c编译生成一个global.o ，然后再和其它文件的.o链接生成可执行文件。
 
 
简单的例子（头文件中声明，源文件中定义）：
 
get_value.h
 

extern int test_int; 外部声明
extern const char *arr[];
int get_value();
 
get_value.cpp
 

#include "get_value.h"
int test_int = 10;
const char *arr[] = {"aa","bb"};
int get_value(){
//    test_int = 10;
    return 0;
}
 
main.c
 

#include <stdio.h>
#include "get_value.h"


//extern int test_int;


int main(){
   //get_value();
   printf("%d\n", test_int);
   printf("%s\n", arr[0]);
   printf("%d\n", sizeof(arr) / sizeof(char*)); //错误，语音如下：
   return 0;
}

     sizeof不能用于extern变量：
            sizeof 的计算发生在代码编译 的时刻。。
            extern 标注的符号 在链接的时刻解析。。。 
            所以 sizeof 不知道 这个符号到底占用了多少空间。
 
 
用static声明
 
        有时在程序中希望某些外部变量只限于被本文件引用，而不能被其他文件引用。这时就可以在定义外部变量时在其前面加一个static声明。此时的外部变量也成为静态全局变量。这个方法虽然可以解决multiple definition的问题，但是却会引发其他问题。 
 
问题如下：
        三个文件a.h、a.c、b.c；
        在a.c和b.c 包含include了a.h。  
        在b.c中调用a.c中的函数对a.h中的变量进行赋值，但事实上b.c中的变量仍没被赋值。
 问题分析：
        static的含义是迫使那个变量只在某个文件可见。 
        假定你在头文件定义static x; 
        且这个头文件分别被a.c和b.c包含;
        实质是在a.c和b.c里会分别定义一个名字叫x的变量，两个x毫无关系。
        在a.c里修改x，他不会导致b.c里的x变化.
 
条件编译
 
注：此方法不是解决上述问题的方法，只是解决multiple definition of的一个方法。
 当多个文件包含同一个头文件时，而头文件中没有加上条件编译，就会独立的解释,然后生成每个文件生成独立的标示符。在编译器连接时，就会将工程中所有的符号整合在一起，由于，文件中有重名变量，于是就出现了重复定义的错误。 
 给每一个头文件加上条件编译，避免该文件被多次引用时被多次解释，这是个应该是习惯。这个方法会解决大部分低级问题。
 条件编译示例
 #ifndef TEST_H
 #define TEST_H
 ……
 #endif
 
 

 
 
出错原因：一般是因为在头文件里进行了定义或者实例化，导致多重定义，记住在头文件里只进行声明。
 

版权声明：本文为博主原创文章，未经博主允许不得转载。https://blog.csdn.net/qq_42680327 
 
问题：
 
用C语言编写程序的时候，我们经常会遇到这样一种情况：希望在头文件中定义一个全局变量，然后包含到两个不同的c文件中，希望这个全局变量能在两个文件中共用。
 
Extern：
 
使用extern关键字来声明变量为外部变量。具体说就是在其中一个c文件中定义一个全局变量key，然后在另一个要使用key这个变量的c文件中使用extern关键字声明一次，说明这个变量为外部变量，是在其他的c文件中定义的全局变量。请注意我这里的用词：定义和声明。例如在01.c文件中定义变量key，在02.c文件中声明key变量为外部变量，这样这两个文件中就能共享这个变量key了。 
 
#include <stdio.h>
int A;      /*定义外部变量*/
void main(){
    int power(int n);       /*函数声明*/
    int b=3,result,c,m;
    printf("please input number A and its power m:\n");
    scanf("%d %d",&A,&m);
    c=A*b;
    printf("%d * %d =%d\n",A,b,c);
    result=power(m);
    printf("%d ^ %d =%d\n",A,m,result);
}
 
extern A;/*声明A为一个已定义的外部变量*/
int power(int n){
    int i,y=1;
    for(i=1;i<=n;i++){
        y*=A;
    }
    return y;
}
 
如图所示：
 
 
其实就是变量定义和变量声明的区别，变量定义使用“数据类型+变量名称”的形式，编译器需要给他分配内存单元的；而变量声明使用“extern 变量类型+变量名称”的形式，是告诉编译器我这个变量将在其他外部c文件中定义，我这里只是在外部用它。编译器就不给他分配内存空间，而等到真正遇到变量定义的时候再给他分配内存空间。
 
用static声明外部变量：
 
有时在程序设计中希望某些外部变量只限于被本文件引用，而不能被其他文件引用。这时可以在定义外部变量时加一个static声明。
 
 
在上面的程序中，我们可以看出用static声明，程序就会报错。解决方法：可以把file02.c文件放进file01.c文件中，就OK 

1：设有以下说明语句：
 struct lie
 {
 int a;
 float b;
 }st;
 则下面叙述中错误的是（ ）。
 
A: struct是结构类型的关键字
 B: struct lie 是用户定义的结构类型
 C: st是用户定义的结构类型名
 D: a和b都是结构成员名
 正确答案：C
 
解析：st是变量名，是用户自己定义的。
 
2：设有如下定义：
 struct sk
 {int a; float b;} data, *p;
 若有p=&data，则对data中的成员a的正确引用是（ ）。
 
A: (*p).data.a　
 B: (*p).a　
 C: p->data.a　
 D: p.data.a
 正确答案：B
 
解析：*p是一个指针，指向成员列表a。
 
3：以下选项中，能定义s为合法的结构体变量的是（ ）。
 
A) typedef struct abc　
 {double a；
 char b[10]；
 }s；
 B) struct
 {double a；
 char b[10]；
 }s；
 C) struct ABC
 {double a；
 char b[10]；
 }
 ABC s； D) typedef ABC
 { double a；
 char b[10]；
 }
 ABC s；
 A: 在题目描述中
 B: 在题目描述中
 C: 在题目描述中
 D: 在题目描述中
 正确答案：B
 
解析：结构体一般命名形势为
 struct
 {成员列表
 }变量名列表；
 
4：若有说明：long *p, a; 则不能通过scanf语句正确给输入项读入数据的程序段是（ ）。
 
A: *p=&a; scanf(“%ld”,p);
 B: p=(long *)malloc(8); scanf(“%ld”,p);
 C: scanf(“%ld”,p=&a);
 D: scanf(“%ld”,&a);
 正确答案：A
 
解析：A选项指针变量没有初始化。
 
5：结构体变量作参数时是地址传递。 （N）
 
解析：结构体变量作参数时还有其他的作用。
 
6：C语言中，关键字enum可用于结构类型的定义。（N）
 
解析：enum 是一个新的关键字，专门用来定义枚举类型。
 
7：若有以下说明和语句：
 struct Student
 {
 int num;
 int age;
 }stu,p;
 p=&stu;
 则可以用p.age引用stu中成员age （N）
 8：若有赋值语句p=（double*）malloc(10*sizeof(double));,则正确的定义语句是（ ）
 
A: double *p
 B: float **p
 C: double **p
 D: float *p
 正确答案：（A）
 
解析：必要要用double类型的，要一致性。
 
9： 以下选项中，非法的字符常量是（ ）。
 A: ‘\t’
 B: ‘\17’
 C: “n”
 D: ‘\xaa’
 正确答案：（C）
 
解析：C选项只能表示为’n’。
 
10：若有说明：int a[3][4]={0};则下面正确的叙述是（ ）
 
A: 只有元素a[0][0]可得到初值0
 B: 此说明语句不正确
 C: 数组a中各元素都可得到初值，但其值不一定为0
 D: 数组a中每个元素均可得到初值0
 正确答案：（D）
 
解析：a[3][4]中只要后面的没有定义，后面的值就直接默认为0。
 
11：若有语句int a[10]={0,1,2,3,4,5,6,7,8,9},*p=a；则( )不是对a数组元素的正确引用（其中0≤i<10）。
 
A: p[i]
 B: ((a+i))
 C: a[p-a]
 D: *(&a[i])
 正确答案：（B）
 12：在C语言中，合法的字符常量是（ ）。
 
A: ‘\084’
 B: ‘\x43’　
 C: ‘ab’
 D: “\0”
 正确答案：（B）
 
解析：A选项只要遇到’\0’就只停止，C选项是个错误的符号，应改为’ab’，D应改为’\0’。
 
13：语句int(*prt)()；的含义是____________。
 
A: prt是一个指向一维数组的指针变量
 B: prt是指向int型数据的指针变量
 C: prt是指向函数的指针，该函数返回一个int型数据
 D: prt是一个函数名，该函数的返回值是指向int型数据的指针
 正确答案：（C）
 
解析：prt是一个指针。
 
14：在下列叙述中，正确的一条是（ ）。
 
A: puts和gets函数只能输入或输出一个字符串
 B: 在C语言中，函数可以递归调用或递归定义
 C: 用scanf函数输入数据时可以规定精度，例如scanf("%7.2f",&a);
 D: 外部变量只限于本文件中使用
 正确答案：（A）
 
解析：只有scanf才能输入多个字符串。
 
15： int a=5,*p;p=&a;则p的值为5.（N）
 
解析：&a是指向a的指针，与它类型匹配的是int (*)，而不是int *。所以p=&a;的等号两边类型不匹配
 
16：若k是int型变量，且有下面的程序片段：
 k= -3;
 if(k<=0) printf(“####”)
 else printf(“&&&&”)
 上面程序片段的输出结果是（ ）。
 
A: ####
 B: &&&&
 C: ####&&&&
 D: 有语法错误，无输出结果
 正确答案：（D）
 
解析：有语法错误，会默认输出第一个。
 
17：下面四个选项中，均是合法整型常量的选项是( )。
 
A: 160 -0xffff 011
 B: -0xcdf 01a 0xe
 C: -01986 012 0668
 D: -0x48a 0x2e5 0x
 
正确答案：（A）
 
解析：整型常量就是整常数，10进制数、8进制数和16进制数三种。如：10、012、0x0A。
 
18：在下列选项中，没有构成死循环的程序段是（ ）。
 A) int i=100; 　　　　　B) for(;😉;
 while(1)
 {i=i%100+1;
 if(i>100) break;
 }
 C) int k=1000;　　　　　D) int s=36;
 do{++k;} while(s);–s;
 while(k>=10000);
 
A: 在题目中
 B: 在题目中
 C: 在题目中
 D: 在题目中
 正确答案：（A）
 
解析：A选项i会一直加，加到100的时候遇到break就会跳出循环结束。
 
19：以下程序的输出结果是（ ）。
 #include<stdio.h>
 #define FUDGE(y) 2.84+y
 #define PR(a) printf("%d", (int)(a))
 #define PRINT1(a) PR(a); putchar(‘\n’)
 main()
 {int x=2;
 PRINT1(FUDGE(5)*x);
 }
 
A: 11
 B: 12
 C: 13
 D: 15
 正确答案：（B）
 20：以下正确的定义语句和赋值语句是_________。
 
A: int b[3][5],(*p)[3],(*q)[5];p=b;q=b;
 B: float b[3][5],*p[3];p[0]=b[0];p[2]=*b+4;
 C: double b[3][5],s[5][3],*q;q=b;s=q;
 D: int b[10],*q;char *s;q=b;s=b;
 正确答案：（B）
 
21：C语言中，在进行混合运算时，数据类型由高级向低级转换。（N）
 
解析：①若参与运算量的类型不同，则先转换成同一类型，然后进行运算
 
    ②转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算

        a、若两种类型的字节数不同，转换成字节数高的类型

        b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型

    ③所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算

    ④char型和short型参与运算时，必须先转换成int型

    ⑤在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入
 
22：fseek函数中的第二个参数代表的位移量是相对于文件的开始来说的。（N）
 
解析：fseek函数的调用形势为
 fseek（文件类型指针，位移量，起始点）
 “位移量”指以“起始点”为基点，向前移动的字节数。
 
23：rewind函数的作用是位置指针返回移动前的位置。（N）
 
解析：
 rewind() 用来将位置指针移动到文件开头，前面已经多次使用过，它的原型为：
 void rewind ( FILE *fp );
 
24：int *p;定义了一个指针变量p,其值是整型的。（N）
 
解析：指针作为一种类型，在不同的系统中实现是不同的， 概念上就不是整形，只是在32位系统中指针是占2个字节。
 25：
 阅读下列程序：
 main()
 {int i, j, row, column, m;
 int array[3][3]={{100, 200, 300}, {28, 72, －30}, {－850, 2, 6}};
 m=array[0][0];
 for(i=0; i<3; i++)
 for(j=0; j<3; j++)
 if(array[i][j]<m)
 {m=array[i][j]; row=i; column=j;}
 printf("%d, %d, %d\n", m, row, column);
 }
 上述程序的输出结果是 。
 正确答案：
 -850,2,0
 
解析：把这串代码放到VC上运行下就出来了。
 
26： 在下面的条件语句中（其中S1和S2标识C语言语句）一个功能上与其他三个语句不等价的是（ ）
 
A: if(a)S1;else S2
 B: if(a0)S2;else S1
 C: if(a!=0)S1;else S2
 D: if(a0)S1;else S2
 正确答案：（D）
 
解析：第四个与前面三个相反了。
 
27：当a=1,b=3,c=5,d=4时，执行完下面的程序段后x的值是（ ）
 if(a<b)if(c<d)x=1;else if(a<c)if(b<d)x=2;else x=3;else x=6;else x=7;
 
A: 1
 B: 2
 C: 3
 D: 4
 正确答案：（B）
 
解析：应该b<d，所以直接输出x=2。
 
28： 若int i=10;执行下列程序后，变量i的正确结果是（ ）
 switch(i){
 case 9:i+=1;
 case 10:i+=1;
 case 11:i+=1;
 default:i+=1;
 }
 
A: 10
 B: 11
 C: 12
 D: 13
 正确答案：（D）
 
解析：应为case 后面没有加break,所以他会一直运行下去，直到default才会停止。
 
29：若希望当A的值为奇数时，表达式的值为”真”，A的值为偶数时，表达式的值为”假”，则以下不能满足要求的表达式是（ ）。
 
A: A%21　
 B: !(A%20)
 C: !(A%2)
 D: A%2
 正确答案：（C）
 
解析：(A%2) 取a除以2的余数，并取反。
 
30： 若有说明语句int i=5,j=4,k=6;float f;则执行f=(i<j&&i<k)?i:(j<k)?j:k;语句后，f的值为（ ）
 
A: 4.0
 B: 5.0
 C: 6.0
 D: 7.0
 正确答案：（A）
 
解析：第一个括号内不成立，所以看第二个括号，j<k成立输出j，j的值为4，所以f的值应为4。
 
31：逻辑运算符两侧运算对象的数据类型（ ）
 
A: 只加粗样式能0或1
 B: 只能是0或非0正数
 C: 只能是整型或字符型数据
 D: 可以是任何类型的数据
 正确答案：（D）
 
解析：但准确的说是任何简单数据类型都是可以的.
 char,int ,long ,unsigned,float ,double,c就是这几个基本的数据类型,都可以用在逻辑运算中.
 
32：指针是变量，它具有的值是某个变量或对象的地址值，它还具有一个地址值，这两个地址值是相等的。（N）
 
解析：指针是程序数据在内存中的地址，而指针变量是用来保存这些地址的变量，这两个值是不相等的。
 33 ：
 如果strcmp(s1,s2)返回的结果为0，表示字符串s1和s2不相同。
 ( N )
 
解析：
 （1）如果字符串1与字符串2相同，则函数值为0。
 （2）如果字符串1>字符串2，则函数值为一个正整数。
 （3）如果字符串1<字符串2，则函数值为一个负整数。
 
34：
 C 语言中在字符型变量可以存放一个字符串。 ( N )
 解析：字符串常量不能修改其内容。

一、静态变量：
 
在了解静态变量之前，读者需要知道什么是全局变量和局部变量。局部变量直至定义在函数内部的变量，在函数调用结束后，局部变量将消失。全局变量是指在函数体外定义的变量，它的生命期随着程序的结束而结束。
 
对于静态变量读者可以简单粗暴地理解为全局变量，但是二者又有区别。如果定义一个静态的局部变量，它的生命期在函数调用结束后依然存在，在下次调用函数时，会依然保存上一次函数调用结束之后的值。并且，对于静态变量只执行一次初始化（无论函数调用多少次）。在 C++中静态变量是使用 static 关键字来定义的。
 
void Invoke()
{
    static int s_nNum = 0;  //定义静态局部变量
    cout << s_nNum << endl;
    s_nNum++;
}

int main()
{
    for(int i = 0; i < 10; i++)
        Invoke();
    return 0;
}

 
注：对于普通的局部变量，在函数调用时每次都会执行初始化操作，并且在函数调用结束后被销毁。对于全局变量来说，不仅能够够在当前文件中使用，而且还可以在其他文件中被使用。但是全局静态变量则不同，它的作用域是当前定义全局静态变量处到当前文件的结束，不能够在其他文件中访问全局静态变量。
 
二、静态数据成员
 
在类中使用 static 关键字将数据成员定义为静态成员。静态成员与静态变量是两个完全不同的概念，静态数据成员能够被同一个类的所有对象共享，可以作用于类上，通过类名来访问，简单的说，就是静态数据成员是属于这个类的全局变量。
 
#include <iostream>
using namespace std;

class CUser
{
private:
    char m_Username[128];
    char m_Password[128];
public:
    static int m_nCount;  //静态数据成员
    CUser()              //默认构造函数
    {
        strcpy(m_Username, "MR");
        strcpy(m_Password, "KJ");
    }
};

int CUser::m_nCount = 10;  //静态成员初始化，不需要在前边加 static

int main()
{
    CUser User;
    cout << "User 静态成员：" << User.m_nCount << endl;
    CUser defUser;
    defUser.m_nCount = 1;
    cout << "defUser 静态成员：" << defUser.m_nCount << endl;
    cout << "User 静态成员：" << User.m_nCount << endl;
    return 0;
}
/*=====output=======
User 静态成员：10
defUser 静态成员：1
User 静态成员：1
==================*/
 
注：对于 VC++的工程来说，静态数据成员的使用，必须现在 .h 文件中声明 static 变量，然后在对应的 .c 文件头的下方初始化静态数据成员，方可使用，否则会出现编译错误。如果在本类中调用静态数据成员，则只需要object.static；如果想要在其他类中调用另一个类的静态成员，不需要进行额外的任何操作，只需要在调用处成员变量前边加上类名::即可，例如 class::static。
 
三、外部变量
 
外部变量用于告诉编译器在其他文件的全局区域存在一个全局变量，目的是在当前文件中能够访问这个全局变量。外部变量的生命需要使用 extern 关键字。例如，在应用程序中，如果在一个文件中定义了一个全局变量，例如 m_nCount，为了在其他文件中能够访问全局变量 m_nCount，那么在其他文件中需要声明一个与 m_nCount 同名的外部变量。
 
extern int m_nCount;
 
四、自动变量
 
（1）C++98 中 auto 特性
 
自动变量是指变量的生命期在变量的声明时开始，在离开变量的作用域时结束，它仅限于在函数内使用。不可申明为全局的。自动变量用 auto 来声明。
 
（2）C++11 中 auto 特性
 
auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型,详见另一位博主的文章
 
https://www.cnblogs.com/QG-whz/p/4951177.html