C Language
Opslagklassen

Invoering

Syntaxis

• [auto | register | statisch | extern] <Gegevenstype> <Variabelenaam> [= <waarde>];

• [statische _Thread_local | extern _Thread_local | _Thread_local] <Gegevenstype> <Naam variabele> [= <waarde>]; / * sinds> = C11 * /

• Voorbeelden:

• typedef int foo ;

• extern int foo [2];

Opmerkingen

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

Definieert een nieuw type op basis van een bestaand type. De syntaxis weerspiegelt die van een variabele declaratie.

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

Hoewel het technisch gezien geen opslagklasse is, zal een compiler het als één behandelen, omdat geen van de andere opslagklassen is toegestaan als het sleutelwoord typedef wordt gebruikt.

De typedef s zijn belangrijk en mogen niet worden vervangen door #define macro.

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

Echter,

#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

auto

Deze opslagklasse geeft aan dat een ID een automatische opslagduur heeft. Dit betekent dat zodra het bereik waarin de identifier werd gedefinieerd, eindigt, het object dat wordt aangegeven door de identifier niet langer geldig is.

Aangezien alle objecten, die niet in een wereldwijd bereik leven of static worden verklaard, standaard een automatische opslagduur hebben wanneer gedefinieerd, is dit trefwoord meestal van historisch belang en mag het niet worden gebruikt:

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

statisch

De static opslagklasse dient verschillende doeleinden, afhankelijk van de locatie van de aangifte in het bestand:

1. Om de identifier alleen te beperken tot die vertaaleenheid (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. Gegevens opslaan voor gebruik bij de volgende aanroep van een functie (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;
    }
   

   Deze code drukt af:

    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
   

Statische variabelen behouden hun waarde, zelfs wanneer ze vanuit meerdere verschillende threads worden aangeroepen.

extern

Wordt gebruikt om een object of functie aan te geven die elders is gedefinieerd (en die externe koppeling heeft ). Over het algemeen wordt het gebruikt om aan te geven dat een object of functie moet worden gebruikt in een module die niet degene is waarin het overeenkomstige object of functie is gedefinieerd:

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

registreren

Hints voor de compiler dat de toegang tot een object zo snel mogelijk moet zijn. Of de compiler de hint daadwerkelijk gebruikt, is door de implementatie bepaald; het kan het eenvoudigweg behandelen als gelijkwaardig aan auto .

De enige eigenschap die definitief verschilt voor alle objecten die met register zijn gedeclareerd, is dat hun adres niet kan worden berekend. Daardoor kan register een goed hulpmiddel zijn om bepaalde optimalisaties te garanderen:

register size_t size = 467;

is een object dat nooit een alias kan gebruiken omdat geen code zijn adres kan doorgeven aan een andere functie waar het onverwacht kan worden gewijzigd.

Deze eigenschap houdt ook in dat een array

register int array[5];

kan niet in een wijzer naar zijn eerste element vervallen (dwz array verandert in &array[0] ). Dit betekent dat de elementen van een dergelijke array niet toegankelijk zijn en dat de array zelf niet aan een functie kan worden doorgegeven.

In feite is de enige legale gebruik van een array gedeclareerd met een register opslag klasse is de sizeof operator; elke andere operator zou het adres van het eerste element van de array nodig hebben. Daarom moeten arrays in het algemeen niet met het register sleutelwoord worden gedeclareerd, omdat het ze nutteloos maakt voor iets anders dan de grootteberekening van de hele array, wat net zo gemakkelijk kan worden gedaan zonder het register sleutelwoord.

De register is geschikter voor variabelen die binnen een blok zijn gedefinieerd en met hoge frequentie worden benaderd. Bijvoorbeeld,

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