[C]链接和生存周期

链接和生存周期的区别：

• 链接是标识符的属性；
• 生存周期是对象的属性；
• 链接可以是外部(external)，内部(internal)或没有(none)；
• 生存周期可以是自动的、静态的，或已分配的(allocated)；

链接：

一个被声明在多个翻译单元内的标识符，或者在同一个翻译单元内被声明多次的标识符，可以每次指向相同的对象或函数。如示例4，具有外部链接的变量，引用的都是同一个对象；

如果该标识符具有链接，那么它和其他跟它一样具有相同链接的标识符共享一个对象或函数；

只有对象和函数标识符可以有外部或内部链接！所以一些预处理指令不能跨编译单元访问；

 

概念	概念	属于该状态的声明	例外	关于隐藏
外部链接	具有外部链接的标识符，表示整个程序内都是相同的函数或对象。编译器会将这种标识符交给连接器(linker)，由链接器解析(resolve)这类标识符，并且把其他翻译单元和链接库中的相同标识符链接起来。	函数外部使用了不带存储修饰符的函数和对象标识符； 函数外部使用了extern存储修饰符的函数和对象标识符(事实上这是一个不规范的写法，如果你明确这个变量需要被外部引用，最好就是不带任何存储修饰符，如果必要这样做，你需要写成这样示例3)； 函数内部带extern的对象，而这个对象在外部具有外部链接；	如果标识符已经被声明为内部链接，在第一次声明的作用域内做第二次声明，并无法将此标识符的链接变成外部链接，这种情况处在翻译单元内和处在翻译单元外的表现又有不同： 处在不同的翻译单元，那么链接时则报错（示例2）； 处在同一个翻译单元，则沿用内部链接（示例1）；	倘若其他翻译单元中定义了一个外部链接，那么就不能在 此单元内再定义一个外部链接，否则在编译器链接单元阶段会报错；
内部链接	“内部链接的标识符”代表在此翻译单元内是“相同的对象或函数” 。此标识符不会被链接器(linker)处理。因此，你无法在别的翻译单元中使用此标识符，以指向到相同的对象或函数。 具有内部链接的标识符，不会和其他翻译单元内类似的标识符产生冲突（示例5）。然而，如果某个标识符在某翻译单元内具有外部链接，你就无法在该翻译单元内声明此标识符是内部链接的。或者，换句话说，如果在某个翻译单元内声明某个标识符是内部链接，就无法声明和使用另一个翻译单元中“同名称”的外部标识符。	非函数内部，使用static存储修饰符声明的函数或对象；  函数内部带extern的对象，而这个对象在外部具有内部链接（参考 示例1 的变量e）；		在其他翻译单元具有外部链接的情况下在此单元声明一个内部链接，则此单元隐藏外部链接，在此单元内使用内部链接（示例6）
无链接	如果标识符不是外部链接，也不是内部链接，它就是无链接的。每出现这种标识符的声明，就会多出一个新的实体(entity)，也就是编译器需要在内存上创建一个单独的对象仅供此标识符使用。	不是变量名称，也不是函数名称的标识符，比如卷标名称(label name)、结构小标签(tag)和typedef名称；  函数参数；  被声明在函数内，并且没有extern修饰符的对象标识符（包含被声明为static的标识符）；

示例1：

int func1(void);                 // func1具有外部链接。
int a;                           // a具有外部链接。
extern int b = 1;                // b具有外部链接。
static int c;                    // c具有内部链接。

static int e;                    // e具有内部链接。


static void func2(int d)         // func2 具有内部链接； d具有无链接。
{
  extern int a;                  // 此a和上面一样，具有外部链接。
  int b = 2;                     // 此b具有无链接，并且将上面声明的b隐藏起来
  
  extern int c;                  // 此c和上面一样，维持内部链接。

  static int e;                  // e具有无链接，并且将上面声明的e隐藏起来。

  int f;                         // f具有无链接


}

示例2：

//翻译单元A
static int foo = 1024;

//翻译单元B
#include 

extern int foo;
void main(void)
{
    printf("%s:foo:%d\n", __func__, foo);
}

在链接两个编译单元的时候，编译器会抛出错误：

undefined reference to `foo'

 示例3：

//直接初始化带extern的对象，编译器会发出警告
extern int foo = 1024;

//this is recommend.
extern int foo;
int foo = 1024;

 示例4：

//翻译单元A声明变量foo
int foo = 1024;

//翻译单元B定义一个修改foo的函数
void func1(void)
{
    extern int foo;
    foo = 2048;
}

//翻译单元C调用函数修改了foo，并且输出
#include 

extern void func1(void);

void main(void)
{
    func1();
    extern int foo;
    printf("%s:foo:%d\n", __func__, foo);//输出2048
}

 示例5：

//翻译单元A声明一个具有内部链接的foo
static int foo = 1024;

//翻译单元B声明一个具有外部链接的foo，并且让翻译单元C修改这个foo
#include 

extern void func1(void);
int foo = 1;

void main(void)
{
    func1();
    printf("%s:foo:%d\n", __func__, foo);//输出2048
}

//翻译单元C声明一个修改外部foo的函数
void func1(void)
{
    extern int foo;
    foo = 2048;
}

示例6：

//翻译单元A声明一个外部链接
int foo = 1024;

//翻译单元B
#include 

void func1(void);
void func2(void);
static int foo = 1;

void main(void)
{
    printf("%s:foo:%d\n", __func__, foo); //输出1
    func1();
    printf("%s:foo:%d\n", __func__, foo); //输出2048
    func2(); //函数内输出1024，即单元以外的foo还是沿用外部链接那个foo
}

void func1(void)
{
    extern int foo; //foo具有翻译单元作用域，所以就算这里省略掉extern int foo;声明，也可以正常访问到foo
    foo = 2048;
}

//翻译单元C
#include 

void func2(void)
{
    extern int foo;
    printf("%d\n", foo);
}

 

生存周期：

对于理解对象生存周期则简单许多，只需要记住以下几点：

生存周期	描述	情况
进程(静态)生存期	对象会一直存在，直至进程结束； brk()划分的空间直到手动调用调用free()才会释放，否则直至进程结束；	函数外声明的对象； 函数内带static关键字的变量； 函数内带内/外部链接的变量； 通过brk()划分的内存空间，例如malloc()、calloc()、realloc()；
栈(自动)生存期	对象会存在到栈退出	函数自变量；