C Language
Lagringskurser

Introduktion

Syntax

• [auto | register | statisk | extern] <Datatyp> <Variabelnamn> [= <Värde>];

• [statisk _Thread_local | extern _Thread_local | _Thread_local] <Datatyp> <Variabelnamn> [= <Value>]; / * sedan> = C11 * /

• Exempel:

• typedef int foo ;

• extern int foo [2];

Anmärkningar

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

Definierar en ny typ baserad på en befintlig typ. Dess syntax speglar den för en variabel deklaration.

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

Även om det inte tekniskt är en lagringsklass, kommer en kompilator att behandla den som en eftersom ingen av de andra lagringsklasserna är tillåtna om typedef nyckelordet används.

typedef erna är viktiga och bör inte ersättas med #define makro.

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

Dock,

#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

bil

Denna lagringsklass anger att en identifierare har automatisk lagringsvaraktighet. Detta innebär att när det räckvidd i vilket identifieraren definierats upphör, är det objekt som anges av identifieraren inte längre giltigt.

Eftersom alla objekt, som inte lever i global omfattning eller som förklaras static , har automatisk lagringsvaraktighet när de definieras, är detta nyckelord mestadels av historiskt intresse och bör inte användas:

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

statisk

Den static lagringsklassen har olika syften, beroende på platsen för deklarationen i filen:

1. Att endast begränsa identifieraren till den översättningsenheten (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. För att spara data för användning med nästa samtal av en funktion (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;
    }
   

   Den här koden skriver ut:

    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
   

Statiska variabler behåller sitt värde även när de anropas från flera olika trådar.

extern

Används för att förklara ett objekt eller en funktion som definieras någon annanstans (och som har extern länk ). I allmänhet används det för att förklara ett objekt eller en funktion som ska användas i en modul som inte är den där motsvarande objekt eller funktion definieras:

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

Registrera

Tips till kompilatorn att åtkomst till ett objekt ska vara så snabbt som möjligt. Huruvida kompilatorn faktiskt använder tipset är implementeringsdefinierat; det kan helt enkelt behandla det som motsvarande auto .

Den enda egenskapen som är definitivt annorlunda för alla objekt som deklareras med register är att de inte kan få sin adress beräknad. register kan därmed vara ett bra verktyg för att säkerställa vissa optimeringar:

register size_t size = 467;

är ett objekt som aldrig kan alias eftersom ingen kod kan skicka sin adress till en annan funktion där det kan ändras oväntat.

Den här egenskapen innebär också att en matris

register int array[5];

kan inte ruttna till en pekare till det första elementet (dvs. array förvandlas till &array[0] ). Detta innebär att elementen i en sådan grupp inte kan nås och själva matrisen inte kan överföras till en funktion.

I själva verket är den enda lagliga användningen av en grupp som deklareras med en register operatörens sizeof ; någon annan operatör skulle kräva adressen till det första elementet i matrisen. Av den anledningen bör matriser i allmänhet inte deklareras med register eftersom det gör dem värdelösa för något annat än storleksberäkning av hela matrisen, vilket kan göras lika enkelt utan register .

register är mer lämplig för variabler som definieras inuti ett block och nås med hög frekvens. Till exempel,

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