C Language
Klasy pamięci

Wprowadzenie

Składnia

• [auto | register | static | extern] <Typ danych> <Nazwa zmiennej> [= <Wartość>];

• [static _Thread_local | extern _Thread_local | _Thread_local] <Typ danych> <Nazwa zmiennej> [= <Wartość>]; / * od> = C11 * /

• Przykłady:

• typedef int foo ;

• extern int foo [2];

Uwagi

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;

typedef

Definiuje nowy typ na podstawie istniejącego typu. Jego składnia odzwierciedla deklarację zmiennej.

/* 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);

Chociaż technicznie nie jest to klasa pamięci, kompilator potraktuje ją jako jedną, ponieważ żadna z pozostałych klas pamięci nie jest dozwolona, jeśli zostanie użyte słowo kluczowe typedef .

typedef s są ważne i nie należy ich zastępować makrem #define .

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

Jednak,

#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

automatyczny

Ta klasa pamięci oznacza, że identyfikator ma automatyczny czas przechowywania. Oznacza to, że po zakończeniu zakresu, w którym zdefiniowano identyfikator, obiekt oznaczony przez identyfikator przestaje być ważny.

Ponieważ wszystkie obiekty, które nie żyją w zakresie globalnym lub nie są zadeklarowane jako static , mają domyślnie automatycznie ustawiony czas przechowywania, gdy są zdefiniowane, dlatego to słowo kluczowe ma głównie znaczenie historyczne i nie powinno być używane:

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. */

statyczny

static klasa pamięci służy do różnych celów, w zależności od lokalizacji deklaracji w pliku:

1. Ograniczenie identyfikatora tylko do tej jednostki tłumaczeniowej (zakres = plik).

   /* 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. Aby zapisać dane do użycia przy następnym wywołaniu funkcji (zakres = blok):

    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;
    }
   

   Ten kod drukuje:

    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
   

Zmienne statyczne zachowują swoją wartość, nawet gdy są wywoływane z wielu różnych wątków.

zewnętrzny

Służy do deklarowania obiektu lub funkcji zdefiniowanej gdzie indziej (i która ma powiązanie zewnętrzne ). Zasadniczo służy do deklarowania obiektu lub funkcji do użycia w module, który nie jest tym, w którym zdefiniowano odpowiedni obiekt lub funkcję:

/* 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);

zarejestrować

Wskazówki dla kompilatora, że dostęp do obiektu powinien być jak najszybszy. To, czy kompilator rzeczywiście korzysta z podpowiedzi, jest zdefiniowane w implementacji; może po prostu traktować to jako odpowiednik auto .

Jedyną właściwością, która jest zdecydowanie inna dla wszystkich obiektów zadeklarowanych za pomocą register jest to, że nie można obliczyć adresu. W ten sposób register może być dobrym narzędziem do zapewnienia pewnych optymalizacji:

register size_t size = 467;

jest obiektem, który nigdy nie może uzyskać aliasu, ponieważ żaden kod nie może przekazać swojego adresu do innej funkcji, w której można go nieoczekiwanie zmienić.

Ta właściwość sugeruje również, że tablica

register int array[5];

nie może rozpaść się na wskaźnik do pierwszego elementu (tj. array zamienia się w &array[0] ). Oznacza to, że do elementów takiej tablicy nie można uzyskać dostępu, a sama tablica nie może zostać przekazana do funkcji.

W rzeczywistości jedynym dozwolonym użyciem tablicy zadeklarowanej z klasą pamięci register jest operator sizeof ; każdy inny operator wymagałby adresu pierwszego elementu tablicy. Z tego powodu tablice zasadniczo nie powinny być deklarowane słowem kluczowym register ponieważ czyni je bezużytecznym do jakichkolwiek innych czynności niż obliczanie wielkości całej tablicy, co można zrobić równie łatwo bez słowa kluczowego register .

Klasa pamięci register jest bardziej odpowiednia dla zmiennych, które są zdefiniowane w bloku i są dostępne z wysoką częstotliwością. Na przykład,

/* 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);
    }
}