C Language
भंडारण कक्षाएं

परिचय

वाक्य - विन्यास

• [ऑटो | रजिस्टर | स्टेटिक | एक्सटर्नल] <डेटा प्रकार> <परिवर्तनीय नाम> [= <मूल्य>];

• [स्टेटिक _Thread_local | एक्सटर्न _Thread_local | _Thread_local] <Data type> <Variable name> [= <value>]; / * के बाद से = = C11 * /

• उदाहरण:

• typedef int foo ;

• बाहरी 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 क्योंकि 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 घोषित नहीं की जाती हैं, इसलिए परिभाषित होने पर डिफ़ॉल्ट रूप से स्वचालित भंडारण अवधि होती है, यह कीवर्ड ज्यादातर ऐतिहासिक रुचि है और इसका उपयोग नहीं किया जाना चाहिए:

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. पहचानकर्ता को केवल उस अनुवाद इकाई तक सीमित करने के लिए (गुंजाइश = फ़ाइल)।

   /* 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. किसी फ़ंक्शन के अगले कॉल के साथ उपयोग के लिए डेटा को बचाने के लिए (स्कोप = ब्लॉक):

    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
   

स्टैटिक वैरिएबल कई अलग-अलग थ्रेड से बुलाए जाने पर भी अपना मूल्य बनाए रखते हैं।

निर्वासन

एक ऐसी वस्तु या कार्य की घोषणा करने के लिए उपयोग किया जाता है जो कहीं और परिभाषित किया गया हो (और जिसमें बाहरी संबंध हो )। सामान्य तौर पर, इसका उपयोग किसी ऑब्जेक्ट या फ़ंक्शन को एक मॉड्यूल में उपयोग करने के लिए घोषित करने के लिए किया जाता है, वह ऐसा नहीं है जिसमें संबंधित ऑब्जेक्ट या फ़ंक्शन को परिभाषित किया जाता है:

/* 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 size_t size = 467;

एक ऐसी वस्तु है जो कभी भी उर्फ नहीं हो सकती क्योंकि कोई भी कोड किसी अन्य फ़ंक्शन को अपना पता नहीं दे सकता है जहां इसे अप्रत्याशित रूप से बदला जा सकता है।

यह गुण भी एक सरणी से तात्पर्य है

register int array[5];

अपने पहले तत्व (यानी array बदलकर &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);
    }
}