C Language
ストレージクラス

前書き

構文

• [auto | register | static | extern] <データ型> <変数名> [= <値>];

• [静的_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;

typedef

既存の型に基づいて新しい型を定義します。その構文は、変数宣言のそれを反映しています。

/* 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キーワードが使用されている場合、他のストレージクラスは許可されていないため、コンパイラはこれを1とtypedef 。

typedefは重要であり、 #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宣言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
   

静的変数は、複数の異なるスレッドから呼び出された場合でもその値を保持します。

extern

他の場所で定義されている（そして外部のリンケージを持つ） オブジェクトまたは関数を宣言するために使用されます。一般に、対応するオブジェクトまたは関数が定義されていないモジュールで使用されるオブジェクトまたは関数を宣言するために使用されます。

/* 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は特定の最適化を保証するための優れたツールになります。

register size_t size = 467;

予期せず変更される可能性のある別の関数にコードを渡すことができないため、 エイリアスにならないオブジェクトです。

このプロパティは、配列

register int array[5];

その最初の要素へのポインタには崩壊できません（ array &array[0]変わり&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);
    }
}