C Language
Классы хранения

Вступление

Синтаксис

• [auto | register | static | extern] <Тип данных> <Имя переменной> [= <Значение>];

• [static _Thread_local | extern _Thread_local | _Thread_local] <Тип данных> <Имя переменной> [= <Значение>]; / *, так как> = C11 * /

• Примеры:

• typedef int foo ;

• extern int foo [2];

замечания

int static const unsigned a = 5; /* bad practice */
static const unsigned int b = 5; /* good practice */

register int x; /* legal at block scope, illegal at file scope */
auto int y; /* same */

static int z; /* legal at both file and block scope */
extern int a; /* same */

extern int b = 5; /* legal and redundant at file scope, illegal at block scope */

/* legal because typedef is treated like a storage class specifier syntactically */
int typedef new_type_name;

ЬурейеЕ

Определяет новый тип на основе существующего типа. Его синтаксис является зеркальным отображением объявления переменной.

/* Byte can be used wherever `unsigned char` is needed */
typedef unsigned char Byte;

/* Integer is the type used to declare an array consisting of a single int */
typedef int Integer[1];

/* NodeRef is a type used for pointers to a structure type with the tag "node" */
typedef struct node *NodeRef;

/* SigHandler is the function pointer type that gets passed to the signal function. */
typedef void (*SigHandler)(int);

Хотя технически не класс хранения, компилятор будет рассматривать его как один, поскольку ни один из других классов хранения не разрешен, если используется ключевое слово typedef .

typedef s важны и не должны заменяться макросом #define .

typedef int newType; 
newType *ptr;        // ptr is pointer to variable of type 'newType' aka int

Тем не мение,

#define int newType
newType *ptr;        // Even though macros are exact replacements to words, this doesn't result to a pointer to variable of type 'newType' aka int

авто

Этот класс хранения означает, что идентификатор имеет автоматическую продолжительность хранения. Это означает, что когда область, в которой был определен идентификатор, заканчивается, объект, обозначенный идентификатором, более недействителен.

Поскольку все объекты, не проживающие в глобальном масштабе или объявленные static , имеют автоматическую продолжительность хранения по умолчанию при определении, это ключевое слово в основном представляет собой исторический интерес и не должно использоваться:

int foo(void)
{
    /* An integer with automatic storage duration. */
    auto int i = 3;

    /* Same */
    int j = 5;

    return 0;
} /* The values of i and j are no longer able to be used. */

статический

static класс хранения используется в разных целях, в зависимости от местоположения объявления в файле:

1. Ограничить идентификатор только этой единицей перевода (scope = file).

   /* No other translation unit can use this variable. */
   static int i;
   
   /* Same; static is attached to the function type of f, not the return type int. */
   static int f(int n);
   

2. Чтобы сохранить данные для использования со следующим вызовом функции (scope = block):

    void foo()
    {
        static int a = 0; /* has static storage duration and its lifetime is the
                           * entire execution of the program; initialized to 0 on 
                           * first function call */ 
        int b = 0; /* b has block scope and has automatic storage duration and 
                    * only "exists" within function */
        
        a += 10;
        b += 10; 
   
        printf("static int a = %d, int b = %d\n", a, b);
    }
   
    int main(void)
    {
        int i;
        for (i = 0; i < 5; i++)
        {
            foo();
        }
   
        return 0;
    }
   

   Этот код печатает:

    static int a = 10, int b = 10
    static int a = 20, int b = 10
    static int a = 30, int b = 10
    static int a = 40, int b = 10
    static int a = 50, int b = 10
   

Статические переменные сохраняют свое значение даже при вызове из нескольких разных потоков.

внешний

Используется для объявления объекта или функции, которая определена в другом месте (и имеет внешнюю связь ). В общем случае он используется для объявления объекта или функции, которые будут использоваться в модуле, который не является тем, в котором определен соответствующий объект или функция:

/* file1.c */
int foo = 2;  /* Has external linkage since it is declared at file scope. */

/* file2.c */
#include <stdio.h>
int main(void)
{
    /* `extern` keyword refers to external definition of `foo`. */
    extern int foo;
    printf("%d\n", foo);
    return 0;
}

/* Should usually be place in a header file such that all users see the definition */
/* Hints to the compiler that the function `bar` might be inlined */
/* and suppresses the generation of an external symbol, unless stated otherwise. */
inline void bar(int drink)
{
    printf("You ordered drink no.%d\n", drink);
}

/* To be found in just one .c file.
   Creates an external function definition of `bar` for use by other files.
   The compiler is allowed to choose between the inline version and the external
   definition when `bar` is called. Without this line, `bar` would only be an inline
   function, and other files would not be able to call it. */
extern void bar(int);

регистр

Подсказки к компилятору, что доступ к объекту должен быть как можно быстрее. Независимо от того, использует ли данный компилятор подсказку, определяется ли реализация; он может просто рассматривать его как эквивалент auto .

Единственное свойство, которое окончательно отличается для всех объектов, объявленных с помощью register состоит в том, что они не могут вычислить свой адрес. Таким образом, register может быть хорошим инструментом для обеспечения определенных оптимизаций:

register size_t size = 467;

это объект, который никогда не может быть псевдонимом, потому что ни один код не может передать свой адрес другой функции, где он может быть неожиданно изменен.

Это свойство также означает, что массив

register int array[5];

не может распадаться в указатель на его первый элемент (т.е. array превращается в &array[0] ). Это означает, что элементы такого массива не могут быть доступны, и сам массив не может быть передан функции.

Фактически единственным законным использованием массива, объявленного с классом хранения register является оператор sizeof ; любой другой оператор потребует адрес первого элемента массива. По этой причине массивы обычно не должны быть объявлены с ключевым словом register поскольку они делают их бесполезными для чего-либо, кроме вычисления размера всего массива, что можно сделать так же легко без ключевого слова register .

Класс хранения register более подходит для переменных, которые определены внутри блока, и к ним обращаются с высокой частотой. Например,

/* prints the sum of the first 5 integers*/
/* code assumed to be part of a function body*/ 
{ 
    register int k, sum;
    for(k = 1, sum = 0; k < 6; sum += k, k++);
        printf("\t%d\n",sum);
}

_Thread_local

#include <threads.h>
#include <stdio.h>
#define SIZE 5

int thread_func(void *id)
{
    /* thread local variable i. */
    static _Thread_local int i;

    /* Prints the ID passed from main() and the address of the i.
     * Running this program will print different addresses for i, showing
     * that they are all distinct objects. */
    printf("From thread:[%d], Address of i (thread local): %p\n", *(int*)id, (void*)&i);

    return 0;
}

int main(void)
{
    thrd_t id[SIZE];
    int arr[SIZE] = {1, 2, 3, 4, 5};

    /* create 5 threads. */
    for(int i = 0; i < SIZE; i++) {
        thrd_create(&id[i], thread_func, &arr[i]);
    }

    /* wait for threads to complete. */
    for(int i = 0; i < SIZE; i++) {
        thrd_join(id[i], NULL);
    }
}