C语言extern使用方法总结
c extern 变量
c extern 变量
摘要：
一、C语言中extern变量的概念
1.extern关键字的作用
2.全局变量与局部变量的区别
二、extern变量的使用规则
1.声明extern变量的方式
2.使用extern变量的方式
3.extern变量的作用范围
三、extern变量的应用实例
1.模块化编程
2.文件间的变量传递
正文：
C语言是一种支持多文件的编程语言，这就涉及到如何在不同的文件中使用相同的变量。为了解决这个问题，C语言引入了extern关键字。下面将从extern变量的概念、使用规则和应用实例三个方面进行详细介绍。
一、C语言中extern变量的概念
在C语言中，extern关键字用于声明一个变量是在本文件之外定义的，或者说是全局变量。使用extern关键字可以让其他文件访问这个变量。它告诉编译器，该变量在其他文件中已经声明过，因此不需要再重复声明。这样可以减少代码冗余，提高程序的可维护性。
需要注意的是，extern变量与局部变量是不同的。局部变量是在函数内部定义的变量，其作用范围仅限于函数内部，不能被其他函数或文件访问。而extern变量可以在整个程序范围内访问。
二、extern变量的使用规则
1.声明extern变量的方式
要声明一个extern变量，只需在变量定义之前加上extern关键字。例如：
```c
extern int global_var;
```
这样声明的global_var就是一个extern变量，其他文件可以通过这个声明来访问它。
2.使用extern变量的方式
使用extern变量时，只需像使用普通变量一样进行声明和访问。例如：```c
c语言中extern的详细用法解析
一、extern关键字的概述
在C语言中，extern是一个关键字，它用来引用外部变量或者函数。extern关键字告诉编译器，所描述的变量或函数是在其他地方定义的，并且要在当前文件中使用。extern关键字可以用于在文件之间共享变量，也可以用于访问全局变量。
二、extern关键字的用法
1. 引用外部全局变量
在C语言中，如果想要在一个文件中引用其他文件中定义的全局变量，可以使用extern关键字。例如：
```c
extern int global_var;
```
这样就可以在当前文件中使用其他文件中定义的global_var变量。
2. 外部函数的声明
在C语言中，如果想要在一个文件中引用其他文件中定义的函数，可
以使用extern关键字进行声明。例如：
```c
extern void function_name();
```
这样就可以在当前文件中使用其他文件中定义的function_name函数。
3. 使用extern关键字的注意事项
在使用extern关键字时，需要注意以下几点：
- 在声明变量或函数时，不要给出变量或函数的具体实现，只需声明其存在即可。
- 声明时的数据类型、函数参数列表要和实际实现一致，以确保在信息时能够正确匹配。
- 只能在全局作用域和函数的外部使用extern关键字。在函数内部使用extern是无效的。
三、extern关键字的示例
下面通过一个示例来展示extern关键字的用法：
```c
// file1.c
#include <stdio.h>
int global_var = 10;
extern 的用法
extern 的用法
extern是C/C++语言中的关键字，用于告知编译器某个变量、函数或对象的定义存在于其他文件中。使用extern关键字，可以在当前文件中引用其他文件中定义的变量、函数、对象等。
具体用法如下：
1.在当前文件中声明变量的外部引用：当在一个C/C++文件中需要使用其他文件定义的全局变量时，可以使用extern关键字来声明该变量的外部引用。例如：
```c++
extern int global_variable; //声明全局变量global_variable 的外部引用
```
2.在当前文件中声明函数的外部引用：当在一个C/C++文件中需要调用其他文件中定义的函数时，可以使用extern关键字来声明该函数的外部引用。例如：
```c++
extern void external_function(); //声明函数
external_function的外部引用
```
3.在头文件中声明共享的全局变量和函数：当多个源文件需要共享同一个全局变量或函数时，可以将其定义在一个头文件中，并在其他源文件中使用extern关键字来声明外部引用。例如，在header.h 文件中定义了一个全局变量和函数：
```c++
// header.h
extern int shared_variable; //全局变量shared_variable的定义
extern void shared_function(); //函数shared_function的定义
```
然后在其他源文件中使用该头文件并声明外部引用：
c语言extern用法
c语言extern用法
C语言中的extern关键字是一个非常重要的关键字，它可以用来声明一个变量或函数是在其他文件中定义的。在C语言中，当我们需要在一个文件中使用另一个文件中定义的变量或函数时，我们需要使用extern关键字来声明这个变量或函数。
在C语言中，extern关键字的用法有两种，分别是extern变量和extern函数。
1. extern变量
在C语言中，如果我们需要在一个文件中使用另一个文件中定义的变量，我们需要使用extern关键字来声明这个变量。例如，我们在文件A中定义了一个变量x，我们需要在文件B中使用这个变量，我们可以在文件B中使用extern关键字来声明这个变量：
```
// 文件A
int x = 10;
// 文件B
extern int x;
```
这样，在文件B中就可以使用变量x了。需要注意的是，extern
关键字只是声明了这个变量，它并没有定义这个变量。因此，在使用这个变量之前，我们需要在程序中定义这个变量。
2. extern函数
在C语言中，如果我们需要在一个文件中使用另一个文件中定义的函数，我们也需要使用extern关键字来声明这个函数。例如，我们在文件A中定义了一个函数add，我们需要在文件B中使用这个函数，我们可以在文件B中使用extern关键字来声明这个函数：
```
// 文件A
int add(int a, int b) {
return a + b;
}
// 文件B
extern int add(int a, int b);
```
这样，在文件B中就可以使用函数add了。需要注意的是，extern 关键字只是声明了这个函数，它并没有定义这个函数。因此，在使用这个函数之前，我们需要在程序中定义这个函数。
extern用法举例c++
extern用法举例c++
一、概述
extern是C语言中一个非常重要的关键字，它用于声明变量或函数在别的文件中存在，或者在程序运行时从别的文件中加载。本文将通过一些具体的例子来介绍extern的用法。
二、变量声明
1. 声明在别的文件中：
如果我们将一个变量定义放在一个文件中，那么其他文件就不能使用这个变量。但是，如果我们使用extern关键字，就可以在其他文件中引用这个变量。例如：
在文件a.c中：
```c
int var; // 定义变量var
```
在文件b.c中：
```c
extern int var; // 声明变量var在其他文件中存在
```
此时，b.c中的代码就可以使用变量var了。
2. 声明在程序运行时：
如果变量或函数是在程序运行时加载的，那么我们也可以使用extern关键字来引用它。例如，如果我们有一个全局变量，但是想要在程序运行时动态加载它，那么可以使用extern关键字来引用它。例如：
在文件main.c中：
```c
extern int globalVar; // 声明全局变量在其他文件中存在
```
在文件loader.c中：
```c
int globalVar = 42; // 在运行时动态加载全局变量
```
此时，main.c中的代码就可以使用全局变量globalVar了。
三、函数声明
1. 声明在别的文件中：
如果我们将一个函数定义放在一个文件中，那么其他文件就不能调用这个函数。但是，如果我们使用extern关键字，就可以在其他文件中引用这个函数。例如：
在文件a.c中：
```c
extern 用法
extern 用法
在C语言中，extern 是一个关键字，它用于声明变量或函数是在其他文件或模块中定义的。这是一种在不同文件之间共享变量和函数的方法，它可以让我们将程序划分为多个模块，并且可以在不同的模块中使用相同的变量和函数。本文将介绍 extern 的用法和一些实际应用场景。
1. extern 变量
当我们在一个文件中声明一个变量时，如果该变量是在另一个文件中定义的，我们需要使用 extern 关键字来告诉编译器该变量是在其他文件中定义的。例如，在文件 a.c 中定义了一个变量 x： ```
int x = 10;
```
在文件 b.c 中使用该变量时，我们需要在 b.c 中声明该变量：
```
extern int x;
```
这告诉编译器变量 x 是在其他文件中定义的，编译器会在链接时将 x 的实际地址与使用它的代码关联起来。
2. extern 函数
与变量类似，如果我们在一个文件中调用一个函数，而该函数
是在另一个文件中定义的，我们需要使用 extern 关键字来告诉编译器该函数是在其他文件中定义的。例如，在文件 a.c 中定义了一个函数 foo：
```
void foo() {
printf('Hello, world!
');
}
```
在文件 b.c 中调用该函数时，我们需要在 b.c 中声明该函数：
```
extern void foo();
```
这告诉编译器函数 foo 是在其他文件中定义的，编译器会在链接时将函数 foo 的实际地址与调用它的代码关联起来。
3. extern 变量和函数的实际应用
extern变量的用法
extern变量的用法
在 C 语言中，extern 关键字用于声明一个已存在于其他文件中的变量。这使得我们可以在一个源文件中使用另一个源文件中定义的变量。这种变量在多个源文件之间的共享和重用是 C 语言编程的一个重要特性。本文将介绍extern 变量的用法和注意事项。
一、extern 变量的基本用法
1. 在头文件中声明变量
首先，我们可以在一个头文件中声明一个变量。例如，我们创建一个名为my_library.h 的头文件，其中包含一个名为my_var 的变量声明：```c
// my_library.h
#ifndef MY_LIBRARY_H
#define MY_LIBRARY_H
int my_var;
#endif
```
在这个例子中，我们声明了一个整型变量my_var。注意，我们在#ifndef 和#endif 之间定义了我的变量。这些预处理器指令确保只有在第一次包含my_library.h 时才会对my_var 的声明进行解析。
2. 在源文件中包含头文件并使用变量
接下来，我们在一个名为main.c 的源文件中包含my_library.h 头文件并使用my_var 变量：
```c
// main.c
#include <stdio.h>
#include "my_library.h"
int main() {
printf("My variable is set to %d
", my_var);
return 0;
}
```
在这个例子中，我们包含了stdio.h 头文件以使用printf 函数。然后，我们包含了my_library.h 头文件，这使得我们在main 函数中可以访问my_var 变量。编译和运行main.c 文件，我们可以看到my_var 的值被正确打印出来。
extern在c语言中的用法
extern在c语言中的用法
在C语言中，通常将整个程序分为多个源文件来组织代码。每个源文件可以包含各种函数和变量的定义。有时候，我们需要在一个源文件中使用另一个源文件中定义的变量或函数。这时候，就可以使用extern关键字来声明这些外部变量或函数。
1.声明外部变量：
当在一个源文件中声明了一些变量，并且该变量可以在其他源文件中使用时，我们就可以使用extern来进行声明。例如：
// 在文件"file1.c"中定义了一个全局变量
int global_variable;
// 在文件"file2.c"中使用了全局变量
在上面的例子中，我们在"file1.c"文件中定义了一个全局变量global_variable，然后在另一个文件"file2.c"中使用了该变量。为了在"file2.c"文件中使用该变量，我们需要使用extern关键字进行声明。这样，编译器知道global_variable是在其他文件中定义的。
2.声明外部函数：
当在一个源文件中定义了一些函数，并且该函数可以在其他源文件中调用时，我们可以使用extern来进行声明。例如：
// 在文件"file1.c"中定义了一个函数
void foo(;
// 在其他文件中调用函数foo
在上面的例子中，我们在"file1.c"文件中定义了一个函数foo(，然
后在其他文件中调用该函数。为了能够调用foo函数，我们需要使用
extern关键字进行声明。这样，编译器知道foo是在其他文件中定义的。
需要注意的是，extern关键字可以省略。在声明函数时，如果没有
extern的用法
extern的用法
"extern" 是 C 和 C++ 语言中的一个关键字，用于声明外部变量和
外部函数。它的主要作用是在一个源文件中引用另一个源文件中定义的变
量或函数。
当一个变量或函数在一些源文件中被使用，而其定义却在另一个源文
件中时，就需要使用 "extern" 关键字来声明该变量或函数。这是因为编
译器默认情况下只会在当前源文件中查找相应的定义，如果找不到，就会
报未定义错误。为了解决这个问题，我们可以使用 "extern" 来告诉编译
器在其他源文件中查找相应的定义。
下面，我们来详细讨论 "extern" 的用法及其在不同上下文中的使用
情况。
1.声明全局变量:
在一个源文件中声明变量，可以在其他源文件中使用该变量的值。通常，全局变量的声明放在头文件中，而定义则放在相应的源文件中。这样，其他源文件只需通过包含头文件即可使用全局变量。
```c
// header.h
// source1.c
int globalVariable = 10;
// source2.c
#include "header.h"
// 可以使用 globalVariable 变量
```
2.引用全局变量:
在一个源文件中使用其他源文件中定义的全局变量，需要在使用之前进行声明。这样，编译器就知道在其他源文件中查找相应的定义。
```c
// source1.c
int globalVariable = 10;
// source2.c
// 可以使用 globalVariable 变量
```
3.声明外部函数:
在一个源文件中声明函数，可以在其他源文件中调用该函数。同样，函数的声明通常放在头文件中，而定义则放在相应的源文件中。
c语言extern的用法
c语言extern的用法
在C语言中，extern关键字用于声明一个全局变量或函数，该变量或函数可以在其他文件中定义和使用。
extern关键字有以下几种常见用法：
1. 声明全局变量：在一个文件中使用extern关键字声明一个全局变量，然后在其他文件中定义该变量。这样可以实现多个文件共享同一个全局变量。
Example：
file1.c中：
extern int globalVariable; // 声明全局变量
file2.c中：
int globalVariable = 10; // 定义全局变量
2. 声明全局函数：在一个文件中使用extern关键字声明一个全局函数，然后在其他文件中定义该函数。这样可以实现多个文件共享同一个全局函数。
Example：
file1.c中：
extern void function(); // 声明全局函数
file2.c中：
void function() // 定义全局函数
{
// 函数实现
}
3. 声明外部变量：在一个文件中使用extern关键字声明一个变量，该变量可以是其他文件中定义的全局变量。这样可以在当前文件中使用其他文件中定义的全局变量。
Example：
file1.c中：
extern int globalVariable; // 声明外部变量
file2.c中：
int globalVariable = 10; // 定义全局变量
file3.c中：
extern int globalVariable; // 声明外部变量
void function()
{
int localVar = globalVariable; // 使用外部变量
c语言中extern的用法
20XX年c语言中extern的用法
在C语言中，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。下面小编就跟你们详细介绍下c语言中extern的用法，希望对你们有用。
c语言中extern的用法如下：
1. extern修饰变量的声明。举例来说，如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。这里需要注意的是，被引用的变量v的链接属性必须是外链接（external）的，也就是说a.c要引用到v，不只是取决于在a.c中声明extern int v，还取决于变量v本身是能够被引用到的。这涉及到c语言的另外一个话题－－变量的作用域。能够被其他模块以extern修饰符引用到的变量通常是全局变量。还有很重要的一点是，extern int v可以放在a.c中的任何地方，比如你可以在a.c中的函数fun定义的开头处声明extern int v，然后就可以引用到变量v了，只不过这样只能在函数fun作用域中引用v罢了，这还是变量作用域的问题。对于这一点来说，很多人使用的时候都心存顾虑。好像extern声明只能用于文件作用域似的。
1/ 2
2. extern修饰函数声明。从本质上来讲，变量和函数没有区别。函数名是指向函数二进制块开头处的指针。如果文件a.c需要引用b.c中的函数，比如在b.c中原型是int fun(int mu)，那么就可以在a.c中声明extern int fun（int mu），然后就能使用fun 来做任何事情。就像变量的声明一样，extern int fun（int mu）可以放在a.c中任何地方，而不一定非要放在a.c的文件作用域的范围中。对其他模块中函数的引用，最常用的方法是包含这些函数声明的头文件。使用extern和包含头文件来引用函数有什么区别呢？extern的引用方式比包含头文件要简洁得多！extern 的使用方法是直接了当的，想引用哪个函数就用extern声明哪个函数。这大概是KISS原则的一种体现吧！这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。在大型C程序编译过程中，这种差异是非常明显的。
c语言extern的用法
c语言extern的用法
extern是C语言中的一个关键字，可用于修饰变量和函数。它的主
要作用是声明一个全局变量或者函数，以便在其他源文件中使用。
在C语言中，当我们在一个源文件中声明一个全局变量或者函数时，
其作用范围仅限于当前源文件。在其他源文件中想要使用这个全局变量或
函数将会报错。这是因为C语言的编译器在编译的过程中，会首先对每个
源文件进行独立的编译，然后再进行链接。而在链接的过程中，编译器会
将各个源文件中的全局变量和函数进行整合，从而产生最终的可执行文件。因此，在其他源文件中调用未声明的全局变量或函数是非法的。
为了解决这个问题，我们可以使用extern关键字来声明一个全局变
量或者函数。关键字extern用于告诉编译器，我们希望在当前源文件中
使用另一个源文件中已经定义的全局变量或函数。它的基本用法如下：
1.声明全局变量：
extern int num;
在一个源文件中，我们可以这样声明一个全局变量，然后在其他源文
件中使用它。关键字extern告诉编译器，该变量已经在其他源文件中定
义过了。
2.声明函数：
extern void func(;
同样地，在一个源文件中，我们可以这样声明一个函数，然后在其他
源文件中调用它。关键字extern告诉编译器，该函数已经在其他源文件
中定义过了。
需要注意的是，extern关键字只是用于声明变量或函数的存在，并不会分配内存空间。它只是告诉编译器在链接时要去其他源文件中寻找这个变量或函数的定义。
在使用extern关键字时，需要遵循以下几个规则：
1.声明和定义：
extern在c语言中是什么意思
extern在c语言中是什么意思
在C语言中，extern关键字主要用于声明一个变量或函数是在其他文件或程序模块中定义的，而不是在当前文件中定义的。这允许程序员在不同的源文件中共享变量和函数。
以下是extern在C语言中的常见用法：
声明外部变量：当你想在一个文件中使用一个在另一个文件中定义的变量时，你需要使用extern来声明该变量。这告诉编译器该变量的定义在其他地方，而不是在当前文件中。
c复制代码
// file1.c
int myGlobalVariable = 10;
// file2.c
extern int myGlobalVariable; // 声明外部
变量
int main() {
printf("%d\n", myGlobalVariable); // 输
出10
return0;
}
声明外部函数：当你想在一个文件中调用另一个文件中定义的函数时，你也需要使用extern来声明该函数。
c复制代码
// file1.c
void myFunction() {
printf("This is a function!\n");
}
// file2.c
extern void myFunction(); // 声明外部
函数
int main() {
myFunction(); // 调用函数
return0;
}
需要注意的是，虽然extern关键字用于声明变量或函数，但它本身并不创建或分配任何内存。它只是告诉编译器，这些变量或函数在其他地方已经被定义和分配了。
在实际的项目中，为了提高代码的可读性和可维护性，通常会将全局变量和函数的定义放在一个或多个头文件中，并在需要使用这些
c语言extern使用方法
extern int count; // 声明全局变量count，在其他文件中定义
int count; // 定义全局变量count
printf("%d\n", count); // 在任何文件中都可以直接使用变量count
extern int count; // 声明全局变量count
需要注意的是，extern关键字通常用于在不同的源文件中共享全局变量或函数。在同一个源文件中，不需要使用extern来使用该文件中定义的全局变量或函数。
c语言中extern的用法
c语言中extern的用法
1. 引言
C语言中的extern关键字是一个非常重要的关键字，它用于声明一个
全局变量或函数，以便在其他文件中使用。extern关键字的使用方式
非常灵活，可以在不同的场景中发挥不同的作用。本文将深入研究C
语言中extern关键字的用法，探讨其在不同情况下的应用和作用。
2. extern声明全局变量
在C语言中，全局变量是定义在函数外部、文件内部的变量。如果我
们希望在其他文件中使用该全局变量，则需要使用extern关键字进行
声明。通过extern声明全局变量，我们可以将其引入到其他文件，并
且可以通过该外部引用进行访问和修改。
3. extern声明函数
除了可以通过extern声明全局变量外，我们还可以使用它来声明函数。当我们希望在某个文件中调用另一个文件定义的函数时，需要先通过extern进行函数声明。这样，在编译时就能够知道该函数存在，并且
能够正确地调用它。
4. extern与头文件
头文件是C语言编程中常见且重要的概念之一。它通常包含了一些常
见类型定义、宏定义和函数声明等信息。当我们需要在多个源文件之
间共享这些信息时，就需要使用头文件来实现。
通过将相关信息放入头文件中，并在需要使用的源文件中使用
#include指令引入头文件，我们可以在不同的源文件中共享同样的定
义和声明。在头文件中，我们可以使用extern关键字来声明全局变量
和函数，以便在其他源文件中使用。
5. extern与多文件编译
多文件编译是C语言开发中常见的一种方式。通过将程序分割成多个
源文件，可以提高代码的可读性和可维护性。然而，在多个源文件之
c语言 extern用法
c语言extern用法
什么是extern关键字？
在C语言中，`extern`是一个关键字，用于说明一个变量或函数在其他文件中定义。在别的文件中用`extern`来声明这个变量或函数，从而让编译器知道它是在其他文件中定义的。
`extern`关键字有几种用法？
1. 外部变量定义
当我们需要声明一个外部定义的变量时，使用`extern`关键字。外部定义的变量是指在全局范围内声明的变量，其作用域比较大，可以在不同的文件中使用。
在一个源文件中，我们可以用如下的方式定义一个外部变量：
int external_var = 0;
如果在其他文件中需要使用这个变量，可以用`extern`关键字声明该变量:
extern int external_var;
这个声明告诉编译器，这个变量已经在另一个文件中定义。在C语言中，除了函数参数以外的变量默认都是外部变量。
2. 外部函数定义
`extern`关键字也可以用于声明外部定义的函数。在不同的文件中，我们可以使用如下代码定义和声明一个函数：
在一个文件中定义函数
int sum(int a, int b) {
return a + b;
}
在另一个文件中声明函数
extern int sum(int a, int b);
这里的函数`sum()`在一个文件中被定义，而在其他文件中被声明。因为C语言中不允许在一个源文件中定义多个同名函数，因此需要使用`extern`声明重复的函数。
3. 引用已定义的外部变量
如果我们希望在一个文件中使用另一个文件中定义的外部变量，那么就需要使用`extern`关键字。以下是一个示例程序：
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
extern使用方法总结！
作者：VIP用户提交日期：2007-5-16 20:53:00
Extern的问题在于不知道这个关键词出现的时候到底是声明还是定义。
谨记：声明可以多次，定义只能一次。
函数的声明extern关键词是可有可无的，因为函数本身不加修饰的话就是extern的。但是引用的时候一样是需要声明的。
而全局变量在外部使用声明时，extern关键词是必须的，如果变量无extern修饰且没有显式的初始化，同样成为变量的定义，因此此时必须加extern，而编译器在此标记存储空间在执行时加载如内存并初始化为0。而局部变量的声明不能有extern的修饰，且局部变量在运行时才在堆栈部分分配内存。
引用性声明、定义性声明
强符号、弱符号
出现在linux的gcc链接分析中，可以加深链接的理解。
全局变量或函数本质上讲没有区别，函数名是指向函数二进制块开头处的指针。而全局变量是在函数外部声明的变量。函数名也在函数外，因此函数也是全局的。
在使用中，要形成一种风格。
头文件
首先说下头文件，其实头文件对计算机而言没什么作用，她只是在预编译时在#include的地方展开一下，没别的意义了，其实头文件主要是给别人看的。
我做过一个实验，将头文件的后缀改成xxx.txt，然后在引用该头文件的地方用
#include"xxx.txt"
编译，链接都很顺利的过去了，由此可知，头文件仅仅为阅读代码作用，没其他的作用了！
不管是C还是C++，你把你的函数，变量或者结构体，类啥的放在你的.c或者.cpp文件里。然后编译成lib,dll,obj,.o等等，然后别人用的时候最基本的gcc hisfile.cpp yourfile.o|obj|dll|lib 等等。
但对于我们程序员而言，他们怎么知道你的lib,dll...里面到底有什么东西？要看你的头文件。你的头文件就是对用户的说明。函数，参数，各种各样的接口的说明。
那既然是说明，那么头文件里面放的自然就是关于函数，变量，类的“声明”了。记着，是“声明”，不是“定义”。
那么，我假设大家知道声明和定义的区别。所以，最好不要傻嘻嘻的在头文件里定义什么东西。比如全局变量：
#ifndef _XX_头文件.H
#define _XX_头文件.H
int A;
#endif
那么，很糟糕的是，这里的int A是个全局变量的定义，所以如果这个头文件被多次引用的话，你的A会被重复定义
显然语法上错了。只不过有了这个#ifndef的条件编译，所以能保证你的头文件只被引用一次，不过也许还是会岔子，但若多个c文件包含这个头文件时还是会出错的，因为宏名有效范围仅限于本c源文件，所以在这多个c文件编译时是不会出错的，但在链接时就会报错，说你多处定义了同一个变量，
Linking...
incl2.obj : error LNK2005: "int glb" (?glb@@3HA) already defined in incl1.obj
Debug/incl.exe : fatal error LNK1169: one or more multiply defined symbols found
注意！！！
extern
这个关键字真的比较可恶，在声明的时候，这个extern居然可以被省略，所以会让你搞不清楚到底是声明还是定义，下面分变量和函数两类来说：
（1）变量
尤其是对于变量来说。
extern int a;//声明一个全局变量a
int a; //定义一个全局变量a
extern int a =0 ;//定义一个全局变量a 并给初值。
int a =0;//定义一个全局变量a,并给初值，
第四个等于第三个，都是定义一个可以被外部使用的全局变量，并给初值。
糊涂了吧，他们看上去可真像。但是定义只能出现在一处。也就是说，不管是int a;还是extern int a=0;还是int a=0;都只能出现一次，而那个extern int a可以出现很多次。
当你要引用一个全局变量的时候，你就要声明，extern int a;这时候extern不能省略，因为省略了，就变成int a;这是一个定义，不是声明。
（2）函数
函数，函数，对于函数也一样，也是定义和声明，定义的时候用extern，说明这个函数是可以被外部引用的，声明的时候用extern说明这是一个声明。但由于函数的定义和声明是有区别的，定义函数要有函数体，声明函数没有函数体，所以函数定义和声明时都可以将extern省略掉，反正其他文件也是知道这个函数是在其他地方定义的，所以不加extern也行。两者如此不同，所以省略了extern也不会有问题。
比如：
int fun(void)
{
return 0;
}
很好，我们定义了一个全局函数
int fun(void);
我们对它做了个声明，然后后面就可以用了
加不加extern都一样
我们也可以把对fun的声明放在一个头文件里，最后变成这样
int fun(void);//函数声明，所以省略了extern，完整些是extern int fun(void);
int fun(void)
{
return 0;
}//一个完整的全局函数定义，因为有函数体，extern同样被省略了。
然后，一个客户，一个要使用你的fun的客户，把这个头文件包含进去，ok，一个全局的声明。没有问题。
但是，对应的，如果是这个客户要使用全局变量，那么要extern 某某变量；不然就成了定义了。
总结下：
对变量而言，如果你想在本源文件中使用另一个源文件的变量，就需要在使用前用extern 声明该变量，或者在头文件中用extern声明该变量；
对函数而言，如果你想在本源文件中使用另一个源文件的函数，就需要在使用前用声明该变量，声明函数加不加extern都没关系，所以在头文件中函数可以不用加extern。
声明（Declaration）用于说明每个标识符的含义，而并不需要为每个标识符预存储空间。预留存储空间的声明称为定义（Definition）。声明的形式为：声明说明符声明符声明符是由存储类说明符和类型说明符组成的。