C Language
Clases de almacenamiento

Introducción

Sintaxis

• [auto | register | static | extern] <Tipo de datos> <Nombre de variable> [= <Valor>];

• [static _Thread_local | extern _Thread_local | _Thread_local] <Tipo de datos> <Nombre de variable> [= <Valor>]; / * desde> = C11 * /

• Ejemplos:

• typedef int foo ;

• extern int foo [2];

Observaciones

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

Define un nuevo tipo basado en un tipo existente. Su sintaxis refleja la de una declaración de variable.

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

Aunque técnicamente no es una clase de almacenamiento, un compilador lo tratará como uno ya que ninguna de las otras clases de almacenamiento está permitida si se usa la palabra clave typedef .

Los typedef s son importantes y no deben sustituirse con la macro #define .

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

Sin embargo,

#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

Esta clase de almacenamiento denota que un identificador tiene una duración de almacenamiento automática. Esto significa que una vez que el ámbito en el que se definió el identificador termina, el objeto denotado por el identificador ya no es válido.

Dado que todos los objetos, que no viven en el ámbito global o que se declaran static , tienen una duración de almacenamiento automático por defecto cuando se definen, esta palabra clave es en su mayoría de interés histórico y no debe usarse:

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

estático

La clase de almacenamiento static tiene diferentes propósitos, dependiendo de la ubicación de la declaración en el archivo:

1. Para limitar el identificador a esa unidad de traducción solamente (scope = archivo).

   /* 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. Para guardar datos para usar con la próxima llamada de una función (alcance = bloque):

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

   Este código imprime:

    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
   

Las variables estáticas conservan su valor incluso cuando se las llama desde varios subprocesos diferentes.

externo

Se utiliza para declarar un objeto o función que se define en otro lugar (y que tiene un enlace externo ). En general, se utiliza para declarar que un objeto o una función se utiliza en un módulo que no es aquel en el que se define el objeto o función correspondiente:

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

registro

Indica al compilador que el acceso a un objeto debe ser lo más rápido posible. Si el compilador realmente usa la sugerencia está definido por la implementación; simplemente puede tratarlo como equivalente a auto .

La única propiedad que es definitivamente diferente para todos los objetos que se declaran con register es que no pueden calcularse sus direcciones. Por lo tanto, register puede ser una buena herramienta para asegurar ciertas optimizaciones:

register size_t size = 467;

es un objeto que nunca puede ser alias porque ningún código puede pasar su dirección a otra función en la que podría cambiarse inesperadamente.

Esta propiedad también implica que una matriz

register int array[5];

no puede descomponerse en un puntero a su primer elemento (es decir, la array convierte en &array[0] ). Esto significa que no se puede acceder a los elementos de dicha matriz y que la matriz en sí no se puede pasar a una función.

De hecho, el único uso legal de una matriz declarada con una clase de almacenamiento de register es el operador sizeof ; cualquier otro operador requeriría la dirección del primer elemento de la matriz. Por esa razón, los arreglos generalmente no deben declararse con la palabra clave de register ya que los hace inútiles para cualquier otra cosa que no sea el cálculo de tamaño de la matriz completa, lo que puede hacerse con la misma facilidad sin la palabra clave de register .

La clase de almacenamiento de register es más apropiada para las variables que se definen dentro de un bloque y se accede a ellas con alta frecuencia. Por ejemplo,

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

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