我们有两个文件，foo.c和bar.c。

这是foo.c

#include <stdio.h>

volatile unsigned int stop_now = 0;
extern void bar_function(void);

int main(void)
{
  while (1) {
     bar_function();
     stop_now = 1;
  }
  return 0;
}

这是bar。c

#include <stdio.h>

extern volatile unsigned int stop_now;

void bar_function(void)
{
   if (! stop_now) {
      printf("Hello, world!\n");
      sleep(30);
   }
}

正如你所看到的，foo.c和bar.c之间没有共享头文件，但是bar.c在被链接时需要在foo.c中声明的东西，而foo.c在被链接时需要bar.c中的函数。

通过使用'extern'，你告诉编译器，在链接时，它后面的任何内容都将被找到(非静态);不要在当前通道中为它保留任何东西，因为它将在以后遇到。函数和变量在这方面是平等对待的。

如果你需要在模块之间共享一些全局，而不想把它放在/初始化在一个头文件中，它是非常有用的。

从技术上讲，库公共标头中的每个函数都是“extern”，但根据编译器的不同，将它们标记为“extern”几乎没有任何好处。大多数编译器可以自己解决这个问题。如你所见，这些函数实际上是在其他地方定义的。

在上面的例子中，main()只打印一次hello world，但继续输入bar_function()。还要注意，bar_function()在本例中不会返回(因为这只是一个简单的示例)。想象一下stop_now在信号被服务时被修改(因此是volatile)，如果这看起来不够实际的话。

对于信号处理程序、一个你不想放在头文件或结构中的互斥量等，extern非常有用。大多数编译器会优化以确保它们不为外部对象保留任何内存，因为它们知道它们将在定义对象的模块中保留内存。但是，同样，在创建公共函数原型时，使用现代编译器指定它没有什么意义。

The extern keyword informs the compiler that the function or variable has external linkage - in other words, that it is visible from files other than the one in which it is defined. In this sense it has the opposite meaning to the static keyword. It is a bit weird to put extern at the time of the definition, since no other files would have visibility of the definition (or it would result in multiple definitions). Normally you put extern in a declaration at some point with external visibility (such as a header file) and put the definition elsewhere.

内联函数对于extern的含义有特殊的规则。(注意，内联函数是C99或GNU扩展;他们不是原始的C。

对于非内联函数，不需要extern，因为默认情况下它是打开的。

注意，c++的规则是不同的。例如，在要从c++调用的C函数的c++声明上需要extern“C”，关于内联有不同的规则。

extern关键字根据环境的不同有不同的形式。如果声明可用，则extern关键字采用前面在翻译单元中指定的链接。在没有任何此类声明的情况下，extern指定外部链接。

static int g();
extern int g(); /* g has internal linkage */

extern int j(); /* j has tentative external linkage */

extern int h();
static int h(); /* error */

以下是C99草案(n1256)的相关段落:

6.2.2 Linkages of identifiers [...] 4 For an identifier declared with the storage-class specifier extern in a scope in which a prior declaration of that identifier is visible,23) if the prior declaration specifies internal or external linkage, the linkage of the identifier at the later declaration is the same as the linkage specified at the prior declaration. If no prior declaration is visible, or if the prior declaration specifies no linkage, then the identifier has external linkage. 5 If the declaration of an identifier for a function has no storage-class specifier, its linkage is determined exactly as if it were declared with the storage-class specifier extern. If the declaration of an identifier for an object has file scope and no storage-class specifier, its linkage is external.

它没有效果的原因是在链接时，链接器试图解析extern定义(在您的例子中是extern int f())。它是在同一个文件中找到它还是在不同的文件中找到它并不重要，只要找到了它。

希望这能回答你的问题。

我们有两个文件，foo.c和bar.c。

这是foo.c

#include <stdio.h>

volatile unsigned int stop_now = 0;
extern void bar_function(void);

int main(void)
{
  while (1) {
     bar_function();
     stop_now = 1;
  }
  return 0;
}

这是bar。c

#include <stdio.h>

extern volatile unsigned int stop_now;

void bar_function(void)
{
   if (! stop_now) {
      printf("Hello, world!\n");
      sleep(30);
   }
}

正如你所看到的，foo.c和bar.c之间没有共享头文件，但是bar.c在被链接时需要在foo.c中声明的东西，而foo.c在被链接时需要bar.c中的函数。

通过使用'extern'，你告诉编译器，在链接时，它后面的任何内容都将被找到(非静态);不要在当前通道中为它保留任何东西，因为它将在以后遇到。函数和变量在这方面是平等对待的。

如果你需要在模块之间共享一些全局，而不想把它放在/初始化在一个头文件中，它是非常有用的。

从技术上讲，库公共标头中的每个函数都是“extern”，但根据编译器的不同，将它们标记为“extern”几乎没有任何好处。大多数编译器可以自己解决这个问题。如你所见，这些函数实际上是在其他地方定义的。

在上面的例子中，main()只打印一次hello world，但继续输入bar_function()。还要注意，bar_function()在本例中不会返回(因为这只是一个简单的示例)。想象一下stop_now在信号被服务时被修改(因此是volatile)，如果这看起来不够实际的话。

对于信号处理程序、一个你不想放在头文件或结构中的互斥量等，extern非常有用。大多数编译器会优化以确保它们不为外部对象保留任何内存，因为它们知道它们将在定义对象的模块中保留内存。但是，同样，在创建公共函数原型时，使用现代编译器指定它没有什么意义。