C Language
सामान्य चयन

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

• _Generic (असाइनमेंट-एक्सप्रेशन, जेनेरिक-असोक-लिस्ट)

पैरामीटर

टिप्पणियों

जांचें कि क्या एक चर एक निश्चित योग्य प्रकार का है

#include <stdio.h> 

#define is_const_int(x) _Generic((&x),  \
        const int *: "a const int",     \
        int *:       "a non-const int", \
        default:     "of other type")

int main(void)
{
    const int i = 1;
    int j = 1;
    double k = 1.0;
    printf("i is %s\n", is_const_int(i));
    printf("j is %s\n", is_const_int(j));
    printf("k is %s\n", is_const_int(k));
}

आउटपुट:

i is a const int
j is a non-const int
k is of other type

हालाँकि, यदि जेनेरिक मैक्रो इस प्रकार लागू किया जाता है:

#define is_const_int(x) _Generic((x), \
        const int: "a const int",     \
        int:       "a non-const int", \
        default:   "of other type")

आउटपुट है:

i is a non-const int
j is a non-const int
k is of other type

ऐसा इसलिए है क्योंकि सभी प्रकार के क्वालीफायर को _Generic प्राथमिक अभिव्यक्ति की नियंत्रित अभिव्यक्ति के मूल्यांकन के लिए छोड़ दिया जाता है।

टाइप-जेनेरिक प्रिंटिंग मैक्रो

#include <stdio.h>

void print_int(int x) { printf("int: %d\n", x); }
void print_dbl(double x) { printf("double: %g\n", x); }
void print_default() { puts("unknown argument"); }

#define print(X) _Generic((X), \
        int: print_int, \
        double: print_dbl, \
        default: print_default)(X)

int main(void) {
    print(42);
    print(3.14);
    print("hello, world");
}

आउटपुट:

int: 42
double: 3.14
unknown argument

ध्यान दें कि यदि प्रकार न तो int और न ही double , तो एक चेतावनी उत्पन्न होगी। चेतावनी को खत्म करने के लिए, आप उस प्रकार को print(X) मैक्रो में जोड़ सकते हैं।

कई तर्कों के आधार पर सामान्य चयन

यदि एक प्रकार की सामान्य अभिव्यक्ति के लिए कई तर्कों पर चयन किया जाता है, और सभी प्रकार के प्रश्न अंकगणितीय प्रकार के होते हैं, तो नेस्टेड _Generic अभिव्यक्तियों से बचने का एक आसान तरीका नियंत्रण अभिव्यक्ति में मापदंडों के अतिरिक्त का उपयोग करना है:

int max_int(int, int);
unsigned max_unsigned(unsigned, unsigned);
double max_double(double, double);

#define MAX(X, Y) _Generic((X)+(Y),                \
                           int:      max_int,      \
                           unsigned: max_unsigned, \
                           default:  max_double)   \
                    ((X), (Y))

यहां, कंट्रोलिंग एक्सप्रेशन (X)+(Y) का केवल उसके प्रकार के अनुसार निरीक्षण किया जाता है और मूल्यांकन नहीं किया जाता है। चयनित प्रकार निर्धारित करने के लिए अंकगणितीय ऑपरेंड के लिए सामान्य रूपांतरण किए जाते हैं।

अधिक जटिल स्थिति के लिए, ऑपरेटर को एक से अधिक तर्क के आधार पर चयन किया जा सकता है, उन्हें एक साथ नेस्ट करके।

यह उदाहरण चार बाहरी कार्यान्वित कार्यों के बीच चयन करता है, जो दो इंट और / या स्ट्रिंग तर्कों का संयोजन लेते हैं, और उनकी राशि वापस करते हैं।

int AddIntInt(int a, int b);
int AddIntStr(int a, const char* b);
int AddStrInt(const char*  a, int b );
int AddStrStr(const char*  a, const char*  b);

#define AddStr(y)                            \
   _Generic((y),         int: AddStrInt,     \
                        char*: AddStrStr,    \
                  const char*: AddStrStr )

#define AddInt(y)                            \
   _Generic((y),          int: AddIntInt,    \
                        char*: AddIntStr,    \
                  const char*: AddIntStr )

#define Add(x, y)                            \
   _Generic((x) ,        int: AddInt(y) ,    \
                       char*: AddStr(y) ,    \
                 const char*: AddStr(y))     \
                         ((x), (y))

int main( void )
{
    int result = 0;
    result = Add( 100 , 999 );
    result = Add( 100 , "999" );
    result = Add( "100" , 999 );
    result = Add( "100" , "999" );

    const int a = -123;
    char b[] = "4321";
    result = Add( a , b );

    int c = 1;
    const char d[] = "0";
    result = Add( d , ++c );
}

हालांकि ऐसा प्रतीत होता है जैसे तर्क y का एक से अधिक बार मूल्यांकन किया जाता है, यह ¹ नहीं है। दोनों तर्कों का मूल्यांकन केवल एक बार किया जाता है, मैक्रो ऐड के अंत में: ( x , y ) , एक साधारण फ़ंक्शन कॉल की तरह।

¹ (से उद्धृत: ISO: IEC 9899: 201X 6.5.1.1 सामान्य चयन 3)
एक सामान्य चयन की नियंत्रित अभिव्यक्ति का मूल्यांकन नहीं किया जाता है।