如何使用extern在源文件之间共享变量？

本文介绍了如何使用extern在源文件之间共享变量？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！ 问题描述 我知道C中的全局变量有时候有 extern 关键字。什么是 extern 变量？什么是宣言？它的范围是什么？ 这与跨源文件共享变量有关，但它是如何精确地工作的？我在哪里使用 extern ？解决方案使用 extern 只与您构建的程序包含多个链接在一起的源文件相关，其中一些变量已定义例如，源文件 file1.c 需要在其他源文件中引用，例如 file2.c 。 重要的是要了解定义 a 变量，声明 变量： 当编译器被告知存在一个变量（这是它的类型）时，变量被声明;它不会为该变量分配存储。 当编译器为分配存储时，变量是定义的 您可以多次声明一个变量（尽管一次就足够了）。 您只能在给定范围内定义一次。 变量定义也是一个声明，但并非所有变量声明都是定义。 声明和定义全局变量的最佳方法 尽管还有其他的方法，但声明和定义全局变量的干净可靠的方法是使用头文件 file3。 h 到包含变量的 extern 声明。标题是，由定义该变量的一个源文件以及所有引用该变量的源文件包含。对于每个程序，一个源文件（并且只有一个源文件）定义该变量。同样，一个头文件（只有一个头文件）应该声明变量。 file3.h extern int global_variable; / *声明变量* / file1.c #includefile3.h/ *此处提供声明* / #includeprog1.h/ *函数声明* / / *此处定义的变量* / int global_variable = 37; / *根据声明检查定义* / int increment（void）{return global_variable ++; } file2.c #includefile3.h #includeprog1.h #include< stdio.h> void use_it（void） { printf（全局变量：％d \ n，global_variable ++）; } 这是使用它们的最佳方法。 接下来的两个文件完成 prog1 的来源： 请注意，我在标头中的函数声明前使用关键字 extern （如 prog1.h ），以匹配标题中变量声明前面的 extern 。许多人不喜欢在函数前面使用 extern ;编译器不关心 - 最终，只要你一致，我也不会这样做。 prog1.h extern void use_it（void）; //extern在这里是可选的;请参阅上面的注释 extern int increment（void）; //extern在这里是可选的;请参阅上面的注释 prog1.c #includefile3.h #includeprog1.h #include< stdio.h> int main（void） { use_it（）; global_variable + = 19; use_it（）; printf（Increment：％d \\\，increment（））; 返回0; $ / code> prog1 使用 prog1.c ， file1.c ， file2.c ， file3.h 和 prog1.h 。 指南 规则仅由专家打破，只有很好的理由： 头文件只包含 extern 变量声明 - 从来没有 静态或非限定变量定义。 对于任何给定的变量，只有一个头文件声明它（SPOT - $ 源文件永远不会包含 extern 变量声明 - 源文件始终包括声明它们的（唯一）标题。 对于任何给定的变量，只有一个源文件定义变量，最好也初始化它。 （尽管没有必要将明确初始化为零，但它没有任何损害，并且可以做一些很好的，因为程序中只能有一个特定全局变量的初始化定义）。 定义变量的源文件还包含的头文件，以确保定义和声明的一致性。 函数不需要使用 extern 来声明变量。 尽可能避免全局变量 - 使用函数。 如果你不是经验丰富的C程序员，你可以（也可以）停止阅读。 p> 定义全局变量的方法不是很好 使用一些（实际上很多）C编译器，你可以逃脱什么是也称为变量的通用定义。 'Common'在这里将引用到Fortran中用于在源文件之间共享变量的技术，使用（可能命名为）COMMON块。这里发生的是，中的每一个都提供了变量的暂定义。只要不超过一个文件提供初始化的定义，那么各种文件最终会共享一个共同的变量定义： file10.c #includeprog2.h int i; / *不要在可移植代码中执行此操作* / void inc（void）{i ++; } file11.c #includeprog2.h int i; / *不要在可移植代码中执行此操作* / void dec（void）{i--; } file12.c #includeprog2.h #include< stdio.h> int i = 9; / *不要在可移植代码中执行此操作* / void put（void）{printf（i =％d \ n，i）; } 此技术不符合C标准的字母和'一个定义规则，但C标准在其一个定义规则中将其列为常见变体。 因为这种技术并不总是被支持的，所以最好避免使用它，特别是如果你的代码需要可移植。使用这个技巧，你也可以结束无意的类型双关。如果一个的文件声明 i 为 double 而不是 int ，C的类型不安全链接器可能不会发现不匹配。如果你使用的是64位 int 和 double 的a机器，那么你甚至不会得到一个警告;在32位 int 和64位 double 的机器上，你可能会得到一个关于不同大小的警告 - 链接器将使用最大的大小，正如Fortran程序将占用任何常见块的最大大小。 信息性附录J中的C标准中提到这是一个普通的扩展： 接下来的两个文件完成 prog2 的源代码： prog2.h extern void dec（void）; extern void put（void）; extern void inc（void）; prog2.c #includeprog2.h #include< stdio.h> int main（void） { inc（）; put（）; dec（）; put（）; dec（）; put（）; $ / code> prog2 使用 prog2.c ， file10.c ， file11.c ， file12.c ， prog2.h 。 警告 正如这里的评论所述，在我对类似 问题的回答中，对全局变量使用多个定义会导致未定义的行为，这是标准方式任何事情都可能发生的。 可能发生的一件事是该程序的行为与期望的一样; J.5.11大概说，你可能更幸运比你应得的。 但是一个依赖于外部变量的多重定义的程序（带或不带明确的extern关键字）并不是一个严格符合标准的程序，并且不能保证在任何地方都能正常工作。 等同：它包含一个可能会或可能不会显示的错误。 违反准则 faulty_header.h int some_var; / *不要在标题中这样做！ * / 注1：如果标题定义的变量没有 extern 关键字，，那么每个包含头文件的文件都会创建一个变量的临时定义。 broken_header.h int some_var = 13; / *程序中只有一个源文件可以使用这个* / 注2：并初始化变量，那么在一个给定的程序中只有一个源文件可以使用该头文件。 seldom_correct.h static int hidden_​​global = 3; / *每个源文件都有自己的副本* / 注3：如果头文件定义了一个静态变量（有或没有初始化），那么每个源文件最后都会有它自己的'global'变量的私人版本。 如果变量实际上是一个复杂的数组，例如，这可能导致导致代码的极端重复。它可以，非常偶然，是一个明智的方式来达到一些效果，但这是相当不寻常的。 总结 使用我首先展示的标题技术。它可靠地运行，并且无处不在。请注意，特别是声明 global_variable 的头文件包含在每个使用它的文件中 - 包括定义它的文件。这确保了一切都是自洽的。 声明和定义函数也有类似的问题 - 类似的规则适用。但问题是关于变量的具体问题，所以我只有只保留了变量的答案。 （完整的程序使用函数，所以函数声明有$在前面的函数声明中使用关键字 extern 来匹配 extern 在头文件中的变量声明前面，很多人不喜欢在函数前面使用 extern ; 编译器不关心 - 最终，只要你是一致的，我也不会这样做。） 原始回答结束 最后加入 避免代码复制 有时候（并且合法地）提出关于标题中'声明的一个问题，源代码机制中的定义描述这里我有两个文件要保持同步 - 头文件和源文件。通常会跟随一个观察结果，即可以使用宏，以便头可以提供双重职责 - 通常是声明变量，但是如果在头之前设置了特定的宏，包括，它定义了变量。 另一个问题可能是变量需要在每个a数量的'主程序'中定义。这通常是一个虚假的关注;你可以简单地引入一个C源文件来定义变量并链接用每个程序生成的目标文件。 一个典型的方案像这样工作，使用 file3.h 中说明的原始全局变量： file3a.h #ifdef DEFINE_VARIABLES #define EXTERN / * nothing * / #else ＃ define EXTERN extern #endif / * DEFINE_VARIABLES * / EXTERN int global_variable; file1a.c #define DEFINE_VARIABLES #includefile3a.h/ *已定义变量 - 但未初始化* / #includeprog3.h int增量（void）{return global_variable ++; } file2a.c #includefile3a.h #includeprog3.h #include< stdio.h> void use_it（void） { printf（全局变量：％d \ n，global_variable ++）; } 下一个两个文件完成 prog3 的源代码： prog3.h extern void use_it（void）; extern int increment（void）; prog3.c #includefile3a.h #includeprog3.h #include< stdio.h> int main（void） { use_it（）; global_variable + = 19; use_it（）; printf（Increment：％d \\\，increment（））; 返回0; prog3 使用 prog3.c ， file1a.c ， file2a.c ， file3a.h ， prog3.h 。 变量初始化 它不提供全局变量的初始化。使用C99或C11和宏的可变参数列表，您可以定义一个宏来支持初始化。 （使用C89并且不支持宏中的可变参数列表，没有简单的方法来处理任意长的初始化符。） file3b。 h #ifdef DEFINE_VARIABLES #define EXTERN / * nothing * / #define INITIALIZER（.. 。）= __VA_ARGS__ #else #define EXTERN extern #define INITIALIZER（...）/ * nothing * / #endif / * DEFINE_VARIABLES * / EXTERN int global_variable INITIALIZER（37）; EXTERN struct {int a; int b; } oddball_struct INITIALIZER（{41，43}）; 接下来的两个文件完成 prog4 的源代码： prog4.h h3> extern int increment（void）; extern int oddball_value（void）; extern void use_them（void）; prog4.c #includefile3b.h #includeprog4.h #include< stdio.h> int main（void） { use_them（）; global_variable + = 19; use_them（）; printf（Increment：％d \\\，increment（））; printf（Oddball：％d \\\，oddball_value（））; 返回0; prog4 使用 prog4.c ， file1b.c ， file2b.c ， prog4.h ， file3b.h 。 标题警卫 任何标题都应该受到保护，因此类型定义（枚举，结构或联合类型或typedef通常）不会导致问题。标准技术是将头部的主体封装在一个头部警卫中，例如： #ifndef FILE3B_H_INCLUDED #define FILE3B_H_INCLUDED ...标题内容... #endif / * FILE3B_H_INCLUDED * / 标题可能会间接包含两次。例如，对于未显示的类型定义，如果 file4b.h 包含 file3b.h ，和 file1b.c 需要同时使用头文件 file4b.h 和 file3b.h ，然后你有一些更棘手的问题需要解决。显然，你可以修改的头部列表来包含 file4b.h 。但是，您可能不会知道内部依赖关系 - 并且代码应该在理想情况下继续工作。 此外，它会启动因为在包含 file3b.h 之前可能包含 file4b.h 来生成定义，但是 file3b.h 中正常的标头会阻止标题重新包含。 您需要为声明最多包含一次 file3b.h 的主体，并且最多一次包含定义，但您可能需要同时包含一个单一的翻译单元（TU - 一个源文件和的标题组合）。 $ b 然而，这可以通过一个不太无理的限制来完成。 让我们介绍一组新的文件名： external.h 用于EXTERN宏定义等。 file1c.h 来定义类型（特别是， struct oddball ， oddball_struct 类型）。 file2c.h 来定义或声明全局变量。 file3c.c 定义了全局变量。 b $ b file4c.c 它简单地使用全局变量。 file5c.c 这表明你可以声明并定义全局变量。 file6c.c 它表明你可以定义然后（试图）声明全局变量。 $ b $ p 在这些例子中， file5c.c 和 file6c.c 直接包含头部 file2c.h 几次，但这是证明机制起作用的最简单方法。这意味着如果标题间接包含两次，它也是安全的。 这个工作的限制是： 定义或声明全局变量的头本身可能不是本身定义的任何类型。 定义宏DEFINE_VARIABLES。 定义或声明变量的头文件具有程式化的内容。 > external.h / * **此头必须不包含标题保护（例如< assert.h>绝对不能）。 **每次调用时，都会根据当前是否定义了宏DEFINE_VARIABLES来重新定义宏EXTERN，INITIALIZE **。 * / #undef EXTERN #undef INITIALIZE #ifdef DEFINE_VARIABLES #define EXTERN / * nothing * / #define INITIALIZE （...）= __VA_ARGS__ #else #define EXTERN extern #define INITIALIZE（...）/ * nothing * / #endif / * DEFINE_VARIABLES * / file1c.h #ifndef FILE1C_H_INCLUDED #define FILE1C_H_INCLUDED struct oddball { int a; int b; }; extern void use_them（void）; extern int increment（void）; extern int oddball_value（void）; #endif / * FILE1C_H_INCLUDED * / file2c.h / *标准序言* / #if defined（DEFINE_VARIABLES）&& ！defined（FILE2C_H_DEFINITIONS） #undef FILE2C_H_INCLUDED #endif #ifndef FILE2C_H_INCLUDED #define FILE2C_H_INCLUDED #includeexternal.h / *支持宏EXTERN，INITIALIZE * / #includefile1c.h/ * struct oddball的类型定义* / #if！defined（DEFINE_VARIABLES）|| ！定义（FILE2C_H_DEFINITIONS） / *全局变量声明/定义* / EXTERN int global_variable INITIALIZE（37）; EXTERN struct oddball oddball_struct INITIALIZE（{41，43}）; #endif / *！DEFINE_VARIABLES || ！FILE2C_H_DEFINITIONS * / / *标准结语* / #ifdef DEFINE_VARIABLES #define FILE2C_H_DEFINITIONS #endif / * DEFINE_VARIABLES * / #endif / * FILE2C_H_INCLUDED * / file3c.c #define DEFINE_VARIABLES #includefile2c.h/ *现在定义和初始化变量* / int increment（void） {return global_variable ++; } int oddball_value（void）{return oddball_struct.a + oddball_struct.b; } file4c.c #includefile2c.h #include< stdio.h> void use_them（void） { printf（全局变量：％d \ n，global_variable ++）; oddball_struct.a + = global_variable; oddball_struct.b - = global_variable / 2; } file5c.c #includefile2c.h/ *声明变量* / #define DEFINE_VARIABLES #includefile2c.h/ *现在变量定义并初始化* / int increment（void）{return global_variable ++; } int oddball_value（void）{return oddball_struct.a + oddball_struct.b; } file6c.c #define DEFINE_VARIABLES #includefile2c.h/ *现在定义和初始化变量* / #includefile2c.h/ *声明变量* / int increment（void）{return global_variable ++; } int oddball_value（void）{return oddball_struct.a + oddball_struct.b; } 下一个源文件完成为 prog5 ， prog6 和 prog7 ： prog5.c ＃包括file2c.h #include< stdio.h> int main（void） { use_them（）; global_variable + = 19; use_them（）; printf（Increment：％d \\\，increment（））; printf（Oddball：％d \\\，oddball_value（））; 返回0; $ / code> prog5 使用 prog5.c ， file3c.c ， file4c.c ， file1c.h ， file2c.h ， external.h 。 prog6 使用 prog5.c ， file5c.c ， file4c.c ， file1c.h ， file2c.h ， external.h 。 prog7 使用 prog5.c ， file6c.c ， file4c.c ， file1c.h ， file2c.h ， external.h 。 避免了大多数问题。如果一个定义变量的头（如 file2c.h ）包含在的另一个头中（比如 file7c.h ）来定义变量。除了不这样做之外，没有任何的简单方法。 您可以通过修改 file2c.h 转换为 file2d.h ： file2d.h / *标准序言* / #if defined（DEFINE_VARIABLES）&& ！defined（FILE2D_H_DEFINITIONS） #undef FILE2D_H_INCLUDED #endif #ifndef FILE2D_H_INCLUDED #define FILE2D_H_INCLUDED #includeexternal.h / *支持宏EXTERN，INITIALIZE * / #includefile1c.h/ * struct oddball的类型定义* / #if！defined（DEFINE_VARIABLES）|| ！定义（FILE2D_H_DEFINITIONS） / *全局变量声明/定义* / EXTERN int global_variable INITIALIZE（37）; EXTERN struct oddball oddball_struct INITIALIZE（{41，43}）; #endif / *！DEFINE_VARIABLES || ！FILE2D_H_DEFINITIONS * / / *标准结语* / #ifdef DEFINE_VARIABLES #define FILE2D_H_DEFINITIONS #undef DEFINE_VARIABLES #endif / * DEFINE_VARIABLES * / #endif / * FILE2D_H_INCLUDED * / 问题变成'should the头文件包含 #undef DEFINE_VARIABLES ？'如果您从头文件中省略了这些元素，并用 #define 和 #undef ： #define DEFINE_VARIABLES #includefile2c.h #undef DEFINE_VARIABLES 代码（所以头文件不会改变 DEFINE_VARIABLES 的值），那么你应该干净。 必须记住要写出额外的行，这真是令人讨厌。替代方案可能是： pre $ #define HEADER_DEFINING_VARIABLESfile2c.h #includeexterndef.h externdef.h / * **这个头文件不能包含头文件（像< assert.h>绝对不能）。 **每次包含它时，宏HEADER_DEFINING_VARIABLES应该以 **的名称（在引号中 - 或者可能是尖括号中）定义 **要包含的头文件定义变量宏 ** DEFINE_VARIABLES被定义时。另请参见：external.h（使用 ** DEFINE_VARIABLES并适当地定义宏EXTERN和INITIALIZE **）。 ** ** #define HEADER_DEFINING_VARIABLESfile2c.h ** #includeexterndef.h * / #if defined （HEADER_DEFINING_VARIABLES） #define DEFINE_VARIABLES #include HEADER_DEFINING_VARIABLES #undef DEFINE_VARIABLES #undef HEADER_DEFINING_VARIABLES #endif / * HEADER_DEFINING_VARIABLES * / 这看起来很安全（使用 file2d.h ，在 file2d.h中 #undef DEFINE_VARIABLES ）。 b $ b file7c.c / *声明变量* / #include file2d.h / *定义变量* / #define HEADER_DEFINING_VARIABLESfile2d.h #includeexterndef.h / *声明变量 - 再次* / #includefile2d.h / *定义变量 - 再次* / #define HEADER_DEFINING_VARIABLESfile2d.h #includeexterndef.h int increment（void）{return global_variable ++; } int oddball_value（void）{return oddball_struct.a + oddball_struct.b; } file8c.h / *标准序言* / #if defined（DEFINE_VARIABLES）&& ！defined（FILE8C_H_DEFINITIONS） #undef FILE8C_H_INCLUDED #endif #ifndef FILE8C_H_INCLUDED #define FILE8C_H_INCLUDED #includeexternal.h / *支持宏EXTERN，INITIALIZE * / #includefile2d.h/ * struct oddball * / #if！defined（DEFINE_VARIABLES）|| ！定义（FILE8C_H_DEFINITIONS） / *全局变量声明/定义* / EXTERN struct oddball another INITIALIZE（{14，34}）; #endif / *！DEFINE_VARIABLES || ！FILE8C_H_DEFINITIONS * / / *标准结语* / #ifdef DEFINE_VARIABLES #define FILE8C_H_DEFINITIONS #endif / * DEFINE_VARIABLES * / #endif / * FILE8C_H_INCLUDED * / file8c.c / *定义变量* / #define HEADER_DEFINING_VARIABLESfile2d.h #includeexterndef.h / *定义变量* / #define HEADER_DEFINING_VARIABLESfile8c.h #includeexterndef.h int increment（void）{return global_variable ++; } int oddball_value(void) { return oddball_struct.a + oddball_struct.b; } The next two files complete the source for prog8 and prog9: prog8.c #include \"file2d.h\" #include <stdio.h> int main(void) { use_them(); global_variable += 19; use_them(); printf(\"Increment: %d\n\", increment()); printf(\"Oddball: %d\n\", oddball_value()); return 0; } file9c.c #include \"file2d.h\" #include <stdio.h> void use_them(void) { printf(\"Global variable: %d\n\", global_variable++); oddball_struct.a += global_variable; oddball_struct.b -= global_variable / 2; } prog8 uses prog8.c, file7c.c, file9c.c. prog9 uses prog8.c, file8c.c, file9c.c. However, the problems are relatively unlikely to occur in practice, especially if you take the standard advice to Avoid global variables Does this exposition miss anything? Confession: The ’avoiding duplicated code’ scheme outlined here was developed because the issue affects some code I work on (but don’t own), and is a niggling concern with the scheme outlined in the first part of the answer. However, the original scheme leaves you with just two places to modify to keep variable definitions and declarations synchronized, which is a big step forward over having exernal variable declarations scattered throughout the code base (which really matters when there are thousands of files in total). However, the code in the files with the names fileNc.[ch] (plus external.h and externdef.h) shows that it can be made to work. Clearly, it would not be hard to create a header generator script to give you the standardized template for a variable defining and declaring header file. NB These are toy programs with just barely enough code to make them marginally interesting. There is repetition within the examples that could be removed, but isn’t to simplify the pedagogical explanation. (For example: the difference between prog5.c and prog8.c is the name of one of the headers that are included. It would be possible to reorganize the code so that the main() function was not repeated, but it would conceal more than it revealed.) I know that global variables in C sometimes have the extern keyword. What is an extern variable? What is the declaration like? What is its scope?This is related to sharing variables across source files, but how does that work precisely? Where do I use extern? 解决方案 Using extern is only of relevance when the program you're buildingconsists of multiple source files linked together, where some of thevariables defined, for example, in source file file1.c need to bereferenced in other source files, such as file2.c.It is important to understand the difference between defining avariable and declaring avariable:A variable is declared when the compiler is informed that avariable exists (and this is its type); it does not allocate thestorage for the variable at that point.A variable is defined when the compiler allocates the storage forthe variable.You may declare a variable multiple times (though once is sufficient);you may only define it once within a given scope.A variable definition is also a declaration, but not all variabledeclarations are definitions.Best way to declare and define global variablesAlthough there are other ways of doing it, the clean, reliable way todeclare and define global variables is to use a header file file3.h tocontain an extern declaration of the variable. The header isincluded by the one source file that defines the variable and by all thesource files that reference the variable. For each program, one sourcefile (and only one source file) defines the variable. Similarly, oneheader file (and only one header file) should declare the variable.file3.hextern int global_variable; /* Declaration of the variable */file1.c#include "file3.h" /* Declaration made available here */#include "prog1.h" /* Function declarations *//* Variable defined here */int global_variable = 37; /* Definition checked against declaration */int increment(void) { return global_variable++; }file2.c#include "file3.h"#include "prog1.h"#include <stdio.h>void use_it(void){ printf("Global variable: %d\n", global_variable++);}That's the best way to use them.The next two files complete the source for prog1:Notice that I use the keyword extern in front of function declarations in headers (as shown in prog1.h, for example) to match the extern in front of variable declarations in headers. Many people prefer not to use extern in front of functions; the compiler doesn't care — and ultimately, neither do I as long as you're consistent.prog1.hextern void use_it(void); // "extern" is optional here; see note aboveextern int increment(void); // "extern" is optional here; see note aboveprog1.c#include "file3.h"#include "prog1.h"#include <stdio.h>int main(void){ use_it(); global_variable += 19; use_it(); printf("Increment: %d\n", increment()); return 0;}prog1 uses prog1.c, file1.c, file2.c, file3.h and prog1.h.GuidelinesRules to be broken by experts only, and only with good reason:A header file only contains extern declarations of variables — neverstatic or unqualified variable definitions.For any given variable, only one header file declares it (SPOT —Single Point of Truth).A source file never contains extern declarations of variables —source files always include the (sole) header that declares them.For any given variable, exactly one source file defines the variable,preferably initializing it too. (Although there is no need toinitialize explicitly to zero, it does no harm and can do some good,because there can be only one initialized definition of a particularglobal variable in a program).The source file that defines the variable also includes the header toensure that the definition and the declaration are consistent.A function should never need to declare a variable using extern.Avoid global variables whenever possible — use functions instead.Not so good way to define global variablesWith some (indeed, many) C compilers, you can get away with what'scalled a 'common' definition of a variable too. 'Common', here, refersto a technique used in Fortran for sharing variables between sourcefiles, using a (possibly named) COMMON block. What happens here is thateach of a number of files provides a tentative definition of thevariable. As long as no more than one file provides an initializeddefinition, then the various files end up sharing a common singledefinition of the variable:file10.c#include "prog2.h"int i; /* Do not do this in portable code */void inc(void) { i++; }file11.c#include "prog2.h"int i; /* Do not do this in portable code */void dec(void) { i--; }file12.c#include "prog2.h"#include <stdio.h>int i = 9; /* Do not do this in portable code */void put(void) { printf("i = %d\n", i); }This technique does not conform to the letter of the C standard and the'one definition rule', but the C standard lists it as a common variationon its one definition rule.Because this technique is not always supported, it is best to avoidusing it, especially if your code needs to be portable. Using thistechnique, you can also end up with unintentional type punning. If oneof the files declared i as a double instead of as an int, C'stype-unsafe linkers probably would not spot the mismatch. If you're ona machine with 64-bit int and double, you'd not even get a warning;on a machine with 32-bit int and 64-bit double, you'd probably get awarning about the different sizes — the linker would use the largestsize, exactly as a Fortran program would take the largest size of anycommon blocks.This is mentioned in the C standard in informative Annex J as a commonextension:The next two files complete the source for prog2:prog2.hextern void dec(void);extern void put(void);extern void inc(void);prog2.c#include "prog2.h"#include <stdio.h>int main(void){ inc(); put(); dec(); put(); dec(); put();}prog2 uses prog2.c, file10.c, file11.c, file12.c, prog2.h.WarningAs noted in comments here, and as stated in my answer to a similarquestion, using multipledefinitions for a global variable leads to undefined behaviour, which isthe standard's way of saying "anything could happen".One of the things that can happen is that the program behaves as youexpect; and J.5.11 says, approximately, "you might be lucky more oftenthan you deserve".But a program that relies on multiple definitions of an extern variable— with or without the explicit 'extern' keyword — is not a strictlyconforming program and not guaranteed to work everywhere.Equivalently: it contains a bug which may or may not show itself.Violating the guidelinesfaulty_header.hint some_var; /* Do not do this in a header!!! */Note 1: if the header defines the variable without the extern keyword,then each file that includes the header creates a tentative definitionof the variable.broken_header.hint some_var = 13; /* Only one source file in a program can use this */Note 2: if the header defines and initializes the variable, then onlyone source file in a given program can use the header.seldom_correct.hstatic int hidden_global = 3; /* Each source file gets its own copy */Note 3: if the header defines a static variable (with or withoutinitialization), then each source file ends up with its own privateversion of the 'global' variable.If the variable is actually a complex array, for example, this can leadto extreme duplication of code. It can, very occasionally, be asensible way to achieve some effect, but that is rather unusual.SummaryUse the header technique I showed first. It works reliably andeverywhere. Note, in particular, that the header declaring theglobal_variable is included in every file that uses it — including theone that defines it. This ensures that everything is self-consistent.Similar concerns arise with declaring and defining functions — analogousrules apply. But the question was about variables specifically, so I'vekept the answer to variables only.(The complete programs use functions, so function declarations havecrept in. I use the keyword extern in front of function declarationsin headers to match the extern in front of variable declarations inheaders. Many people prefer not to use extern in front of functions;the compiler doesn't care — and ultimately, neither do I as long asyou're consistent.)End of Original AnswerLate Major AdditionAvoiding Code DuplicationOne concern that is sometimes (and legitimately) raised about the'declarations in headers, definitions in source' mechanism describedhere is that there are two files to be kept synchronized — the headerand the source. This is usually followed up with an observation that amacro can be used so that the header serves double duty — normallydeclaring the variables, but when a specific macro is set before theheader is included, it defines the variables instead.Another concern can be that the variables need to be defined in each ofa number of 'main programs'. This is normally a spurious concern; youcan simply introduce a C source file to define the variables and linkthe object file produced with each of the programs.A typical scheme works like this, using the original global variableillustrated in file3.h:file3a.h#ifdef DEFINE_VARIABLES#define EXTERN /* nothing */#else#define EXTERN extern#endif /* DEFINE_VARIABLES */EXTERN int global_variable;file1a.c#define DEFINE_VARIABLES#include "file3a.h" /* Variable defined - but not initialized */#include "prog3.h"int increment(void) { return global_variable++; }file2a.c#include "file3a.h"#include "prog3.h"#include <stdio.h>void use_it(void){ printf("Global variable: %d\n", global_variable++);}The next two files complete the source for prog3:prog3.hextern void use_it(void);extern int increment(void);prog3.c#include "file3a.h"#include "prog3.h"#include <stdio.h>int main(void){ use_it(); global_variable += 19; use_it(); printf("Increment: %d\n", increment()); return 0;}prog3 uses prog3.c, file1a.c, file2a.c, file3a.h, prog3.h.Variable initializationThe problem with this scheme as shown is that it does not provide forinitialization of the global variable. With C99 or C11 and variable argumentlists for macros, you could define a macro to support initialization too.(With C89 and no support for variable argument lists in macros, there is noeasy way to handle arbitrarily long initializers.)file3b.h#ifdef DEFINE_VARIABLES#define EXTERN /* nothing */#define INITIALIZER(...) = __VA_ARGS__#else#define EXTERN extern#define INITIALIZER(...) /* nothing */#endif /* DEFINE_VARIABLES */EXTERN int global_variable INITIALIZER(37);EXTERN struct { int a; int b; } oddball_struct INITIALIZER({ 41, 43 });file1b.c#define DEFINE_VARIABLES#include "file3b.h" /* Variables now defined and initialized */#include "prog4.h"int increment(void) { return global_variable++; }int oddball_value(void) { return oddball_struct.a + oddball_struct.b; }file2b.c#include "file3b.h"#include "prog4.h"#include <stdio.h>void use_them(void){ printf("Global variable: %d\n", global_variable++); oddball_struct.a += global_variable; oddball_struct.b -= global_variable / 2;}Clearly, the code for the oddball structure is not what you'd normallywrite, but it illustrates the point. The first argument to the secondinvocation of INITIALIZER is { 41 and the remaining argument(singular in this example) is 43 }. Without C99 or similar supportfor variable argument lists for macros, initializers that need tocontain commas are very problematic.The next two files complete the source for prog4:prog4.hextern int increment(void);extern int oddball_value(void);extern void use_them(void);prog4.c#include "file3b.h"#include "prog4.h"#include <stdio.h>int main(void){ use_them(); global_variable += 19; use_them(); printf("Increment: %d\n", increment()); printf("Oddball: %d\n", oddball_value()); return 0;}prog4 uses prog4.c, file1b.c, file2b.c, prog4.h, file3b.h.Header GuardsAny header should be protected against reinclusion, so that typedefinitions (enum, struct or union types, or typedefs generally) do notcause problems. The standard technique is to wrap the body of theheader in a header guard such as:#ifndef FILE3B_H_INCLUDED#define FILE3B_H_INCLUDED...contents of header...#endif /* FILE3B_H_INCLUDED */The header might be included twice indirectly. For example, iffile4b.h includes file3b.h for a type definition that isn't shown,and file1b.c needs to use both header file4b.h and file3b.h, thenyou have some more tricky issues to resolve. Clearly, you might revisethe header list to include just file4b.h. However, you might not beaware of the internal dependencies — and the code should, ideally,continue to work.Further, it starts to get tricky because you might include file4b.hbefore including file3b.h to generate the definitions, but the normalheader guards on file3b.h would prevent the header being reincluded.So, you need to include the body of file3b.h at most once fordeclarations, and at most once for definitions, but you might need bothin a single translation unit (TU — a combination of a source file andthe headers it uses).Multiple inclusion with variable definitionsHowever, it can be done subject to a not too unreasonable constraint.Let's introduce a new set of file names:external.h for the EXTERN macro definitions, etc.file1c.h to define types (notably, struct oddball, the type of oddball_struct).file2c.h to define or declare the global variables.file3c.c which defines the global variables.file4c.c which simply uses the global variables.file5c.c which shows that you can declare and then define the global variables.file6c.c which shows that you can define and then (attempt to) declare the global variables.In these examples, file5c.c and file6c.c directly include the headerfile2c.h several times, but that is the simplest way to show that themechanism works. It means that if the header was indirectly includedtwice, it would also be safe.The restrictions for this to work are:The header defining or declaring the global variables may not itselfdefine any types.Immediately before you include a header that should define variables,you define the macro DEFINE_VARIABLES.The header defining or declaring the variables has stylized contents.external.h/*** This header must not contain header guards (like <assert.h> must not).** Each time it is invoked, it redefines the macros EXTERN, INITIALIZE** based on whether macro DEFINE_VARIABLES is currently defined.*/#undef EXTERN#undef INITIALIZE#ifdef DEFINE_VARIABLES#define EXTERN /* nothing */#define INITIALIZE(...) = __VA_ARGS__#else#define EXTERN extern#define INITIALIZE(...) /* nothing */#endif /* DEFINE_VARIABLES */file1c.h#ifndef FILE1C_H_INCLUDED#define FILE1C_H_INCLUDEDstruct oddball{ int a; int b;};extern void use_them(void);extern int increment(void);extern int oddball_value(void);#endif /* FILE1C_H_INCLUDED */file2c.h/* Standard prologue */#if defined(DEFINE_VARIABLES) && !defined(FILE2C_H_DEFINITIONS)#undef FILE2C_H_INCLUDED#endif#ifndef FILE2C_H_INCLUDED#define FILE2C_H_INCLUDED#include "external.h" /* Support macros EXTERN, INITIALIZE */#include "file1c.h" /* Type definition for struct oddball */#if !defined(DEFINE_VARIABLES) || !defined(FILE2C_H_DEFINITIONS)/* Global variable declarations / definitions */EXTERN int global_variable INITIALIZE(37);EXTERN struct oddball oddball_struct INITIALIZE({ 41, 43 });#endif /* !DEFINE_VARIABLES || !FILE2C_H_DEFINITIONS *//* Standard epilogue */#ifdef DEFINE_VARIABLES#define FILE2C_H_DEFINITIONS#endif /* DEFINE_VARIABLES */#endif /* FILE2C_H_INCLUDED */file3c.c#define DEFINE_VARIABLES#include "file2c.h" /* Variables now defined and initialized */int increment(void) { return global_variable++; }int oddball_value(void) { return oddball_struct.a + oddball_struct.b; }file4c.c#include "file2c.h"#include <stdio.h>void use_them(void){ printf("Global variable: %d\n", global_variable++); oddball_struct.a += global_variable; oddball_struct.b -= global_variable / 2;}file5c.c#include "file2c.h" /* Declare variables */#define DEFINE_VARIABLES#include "file2c.h" /* Variables now defined and initialized */int increment(void) { return global_variable++; }int oddball_value(void) { return oddball_struct.a + oddball_struct.b; }file6c.c#define DEFINE_VARIABLES#include "file2c.h" /* Variables now defined and initialized */#include "file2c.h" /* Declare variables */int increment(void) { return global_variable++; }int oddball_value(void) { return oddball_struct.a + oddball_struct.b; }The next source file completes the source (provides a main program) for prog5, prog6 and prog7:prog5.c#include "file2c.h"#include <stdio.h>int main(void){ use_them(); global_variable += 19; use_them(); printf("Increment: %d\n", increment()); printf("Oddball: %d\n", oddball_value()); return 0;}prog5 uses prog5.c, file3c.c, file4c.c, file1c.h, file2c.h, external.h.prog6 uses prog5.c, file5c.c, file4c.c, file1c.h, file2c.h, external.h.prog7 uses prog5.c, file6c.c, file4c.c, file1c.h, file2c.h, external.h.This scheme avoids most problems. You only run into a problem if aheader that defines variables (such as file2c.h) is included byanother header (say file7c.h) that defines variables. There isn't aneasy way around that other than "don't do it".You can partially work around the problem by revising file2c.h intofile2d.h:file2d.h/* Standard prologue */#if defined(DEFINE_VARIABLES) && !defined(FILE2D_H_DEFINITIONS)#undef FILE2D_H_INCLUDED#endif#ifndef FILE2D_H_INCLUDED#define FILE2D_H_INCLUDED#include "external.h" /* Support macros EXTERN, INITIALIZE */#include "file1c.h" /* Type definition for struct oddball */#if !defined(DEFINE_VARIABLES) || !defined(FILE2D_H_DEFINITIONS)/* Global variable declarations / definitions */EXTERN int global_variable INITIALIZE(37);EXTERN struct oddball oddball_struct INITIALIZE({ 41, 43 });#endif /* !DEFINE_VARIABLES || !FILE2D_H_DEFINITIONS *//* Standard epilogue */#ifdef DEFINE_VARIABLES#define FILE2D_H_DEFINITIONS#undef DEFINE_VARIABLES#endif /* DEFINE_VARIABLES */#endif /* FILE2D_H_INCLUDED */The issue becomes 'should the header include #undef DEFINE_VARIABLES?'If you omit that from the header and wrap any defining invocation with#define and #undef:#define DEFINE_VARIABLES#include "file2c.h"#undef DEFINE_VARIABLESin the source code (so the headers never alter the value ofDEFINE_VARIABLES), then you should be clean. It is just a nuisance tohave to remember to write the the extra line. An alternative might be:#define HEADER_DEFINING_VARIABLES "file2c.h"#include "externdef.h"externdef.h/*** This header must not contain header guards (like <assert.h> must not).** Each time it is included, the macro HEADER_DEFINING_VARIABLES should** be defined with the name (in quotes - or possibly angle brackets) of** the header to be included that defines variables when the macro** DEFINE_VARIABLES is defined. See also: external.h (which uses** DEFINE_VARIABLES and defines macros EXTERN and INITIALIZE** appropriately).**** #define HEADER_DEFINING_VARIABLES "file2c.h"** #include "externdef.h"*/#if defined(HEADER_DEFINING_VARIABLES)#define DEFINE_VARIABLES#include HEADER_DEFINING_VARIABLES#undef DEFINE_VARIABLES#undef HEADER_DEFINING_VARIABLES#endif /* HEADER_DEFINING_VARIABLES */This is getting a tad convoluted, but seems to be secure (using thefile2d.h, with no #undef DEFINE_VARIABLES in the file2d.h).file7c.c/* Declare variables */#include "file2d.h"/* Define variables */#define HEADER_DEFINING_VARIABLES "file2d.h"#include "externdef.h"/* Declare variables - again */#include "file2d.h"/* Define variables - again */#define HEADER_DEFINING_VARIABLES "file2d.h"#include "externdef.h"int increment(void) { return global_variable++; }int oddball_value(void) { return oddball_struct.a + oddball_struct.b; }file8c.h/* Standard prologue */#if defined(DEFINE_VARIABLES) && !defined(FILE8C_H_DEFINITIONS)#undef FILE8C_H_INCLUDED#endif#ifndef FILE8C_H_INCLUDED#define FILE8C_H_INCLUDED#include "external.h" /* Support macros EXTERN, INITIALIZE */#include "file2d.h" /* struct oddball */#if !defined(DEFINE_VARIABLES) || !defined(FILE8C_H_DEFINITIONS)/* Global variable declarations / definitions */EXTERN struct oddball another INITIALIZE({ 14, 34 });#endif /* !DEFINE_VARIABLES || !FILE8C_H_DEFINITIONS *//* Standard epilogue */#ifdef DEFINE_VARIABLES#define FILE8C_H_DEFINITIONS#endif /* DEFINE_VARIABLES */#endif /* FILE8C_H_INCLUDED */file8c.c/* Define variables */#define HEADER_DEFINING_VARIABLES "file2d.h"#include "externdef.h"/* Define variables */#define HEADER_DEFINING_VARIABLES "file8c.h"#include "externdef.h"int increment(void) { return global_variable++; }int oddball_value(void) { return oddball_struct.a + oddball_struct.b; }The next two files complete the source for prog8 and prog9:prog8.c#include "file2d.h"#include <stdio.h>int main(void){ use_them(); global_variable += 19; use_them(); printf("Increment: %d\n", increment()); printf("Oddball: %d\n", oddball_value()); return 0;}file9c.c#include "file2d.h"#include <stdio.h>void use_them(void){ printf("Global variable: %d\n", global_variable++); oddball_struct.a += global_variable; oddball_struct.b -= global_variable / 2;}prog8 uses prog8.c, file7c.c, file9c.c.prog9 uses prog8.c, file8c.c, file9c.c.However, the problems are relatively unlikely to occur in practice,especially if you take the standard advice toAvoid global variablesDoes this exposition miss anything?Confession: The 'avoiding duplicated code' scheme outlined here wasdeveloped because the issue affects some code I work on (but don't own),and is a niggling concern with the scheme outlined in the first part ofthe answer. However, the original scheme leaves you with just twoplaces to modify to keep variable definitions and declarationssynchronized, which is a big step forward over having exernal variabledeclarations scattered throughout the code base (which really matterswhen there are thousands of files in total). However, the code in thefiles with the names fileNc.[ch] (plus external.h and externdef.h)shows that it can be made to work. Clearly, it would not be hard tocreate a header generator script to give you the standardized templatefor a variable defining and declaring header file.NB These are toy programs with just barely enough code to make themmarginally interesting. There is repetition within the examples thatcould be removed, but isn't to simplify the pedagogical explanation.(For example: the difference between prog5.c and prog8.c is the nameof one of the headers that are included. It would be possible toreorganize the code so that the main() function was not repeated, butit would conceal more than it revealed.) 这篇关于如何使用extern在源文件之间共享变量？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！