Specifystorage duration andlinkage of objects and functions:

• auto - automatic duration and no linkage
• register - automatic duration and no linkage; address of this variable cannot be taken
• static - static duration and internal linkage (unless at block scope)
• extern - static duration and external linkage (unless already declared internal)

[edit]Explanation

Storage-class specifiers appear indeclarations andcompound literal expressions(since C23). At most one specifier may be used, except that_Thread_local(until C23)thread_local(since C23) may be combined withstatic orextern to adjust linkage(since C11). The storage-class specifiers determine two independent properties of the names they declare:storage duration andlinkage.

If no storage-class specifier is provided, the defaults are:

extern for all functions

extern for objects at file scope

auto for objects at block scope

For any struct or union declared with a storage-class specifier, the storage duration (but not linkage) applies to their members, recursively.

Function declarations at block scope can useextern or none at all. Function declarations at file scope can useextern orstatic.

Function parameters cannot use any storage-class specifiers other thanregister. Note thatstatic has special meaning in function parameters of array type.

[edit]Storage duration

Everyobject has a property calledstorage duration, which limits the objectlifetime. There are four kinds of storage duration in C:

• automatic storage duration. The storage is allocated when theblock in which the object was declared is entered and deallocated when it is exited by any means (goto,return, reaching the end).One exception is theVLAs; their storage is allocated when the declaration is executed, not on block entry, and deallocated when the declaration goes out of scope, not when the block is exited(since C99). If the block is entered recursively, a new allocation is performed for every recursion level. All function parameters and non-static block-scope objects have this storage duration,as well ascompound literals used at block scope(until C23)
• static storage duration. The storage duration is the entire execution of the program, and the value stored in the object is initialized only once, prior tomain function. All objects declaredstatic and all objects with either internal or external linkage that aren't declared_Thread_local(until C23)thread_local(since C23)(since C11) have this storage duration.

• allocated storage duration. The storage is allocated and deallocated on request, usingdynamic memory allocation functions.

[edit]Linkage

Linkage refers to the ability of an identifier (variable or function) to be referred to in other scopes. If a variable or function with the same identifier is declared in several scopes, but cannot be referred to from all of them, then several instances of the variable are generated. The following linkages are recognized:

• no linkage. The variable or function can be referred to only from the scope it is in (block scope). All block scope variables that are not declaredextern have this linkage, as well as all function parameters and all identifiers that aren't functions or variables.

• internal linkage. The variable or function can be referred to from all scopes in the current translation unit. All file scope variables which are declaredstaticorconstexpr(since C23) have this linkage, and all file scope functions declaredstatic (static function declarations are only allowed at file scope).

• external linkage. The variable or function can be referred to from any other translation units in the entire program. All file scope variables which are not declaredstatic orconstexpr(since C23) have this linkage, all file scope function declarations which are not declaredstatic, all block scope function declarations, and, additionally, all variables or functions declaredextern have this linkage unless a prior declaration with internal linkage is visible at that point.

If the same identifier appears with both internal and external linkage in the same translation unit, the behavior is undefined. This is possible whententative definitions are used.

[edit]Linkage and libraries

Declarations with external linkage are commonly made available in header files so that all translation units that#include the file may refer to the same identifier that are defined elsewhere.

Any declaration with internal linkage that appears in a header file results in a separate and distinct object in each translation unit that includes that file.

Library interface, header file "flib.h":

#ifndef FLIB_H#define FLIB_Hvoid f(void);// function declaration with external linkageexternint state;// variable declaration with external linkagestaticconstint size=5;// definition of a read-only variable with internal linkageenum{ MAX=10};// constant definitioninlineint sum(int a,int b){return a+ b;}// inline function definition#endif // FLIB_H

Library implementation, source file "flib.c":

#include "flib.h" staticvoid local_f(int s){}// definition with internal linkage (only used in this file)staticint local_state;// definition with internal linkage (only used in this file) int state;// definition with external linkage (used by main.c)void f(void){ local_f(state);}// definition with external linkage (used by main.c)

Application code, source file "main.c":

#include "flib.h" int main(void){int x[MAX]={size};// uses the constant and the read-only variable    state=7;// modifies state in flib.c    f();// calls f() in flib.c}

[edit]Keywords

auto,register,static,extern,_Thread_localthread_local

[edit]Notes

Thetypedef andconstexpr(since C23) specifiers are formally listed as storage-class specifiers in the C language grammar, but do not specify storage.

Names at file scope that areconst and notextern have external linkage in C (as the default for all file-scope declarations), but internal linkage in C++.

[edit]Example

#include <stdio.h>#include <stdlib.h> // static storage durationint A; int main(void){printf("&A = %p\n",(void*)&A); // automatic storage durationint A=1;// hides global Aprintf("&A = %p\n",(void*)&A); // allocated storage durationint* ptr_1=malloc(sizeof(int));// start allocated storage durationprintf("address of int in allocated memory = %p\n",(void*)ptr_1);free(ptr_1);// stop allocated storage duration}

&A = 0x600ae4&A = 0x7ffefb064f5caddress of int in allocated memory = 0x1f28c30

[edit]References

[edit]See also

• In other languages

• العربية
• Česky
• Deutsch
• Español
• Français
• Italiano
• 日本語
• 한국어
• Polski
• Português
• Русский
• Türkçe
• 中文