मैं C में किसी फ़ंक्शन से कई मान कैसे लौटाऊं?

Question 1

अगर मेरे पास एक फ़ंक्शन है जो एक परिणाम intऔर परिणाम पैदा करता है string, तो मैं उन दोनों को एक फ़ंक्शन से कैसे वापस कर सकता हूं?

जहां तक मैं बता सकता हूं कि मैं केवल एक चीज वापस कर सकता हूं, जैसा कि फ़ंक्शन नाम से पहले के प्रकार से निर्धारित होता है।

Question 2

मुझे नहीं पता कि आपका क्या stringहै, लेकिन मैं यह मानने जा रहा हूं कि यह अपनी स्मृति का प्रबंधन करता है।

आपके पास दो समाधान हैं:

1: एक वापसी structजिसमें आपकी ज़रूरत के सभी प्रकार शामिल हैं।

struct Tuple {
    int a;
    string b;
};

struct Tuple getPair() {
    Tuple r = { 1, getString() };
    return r;
}

void foo() {
    struct Tuple t = getPair();
}

2: मानों को पास करने के लिए पॉइंटर्स का उपयोग करें।

void getPair(int* a, string* b) {
    // Check that these are not pointing to NULL
    assert(a);
    assert(b);
    *a = 1;
    *b = getString();
}

void foo() {
    int a, b;
    getPair(&a, &b);
}

जो आप उपयोग करने के लिए चुनते हैं वह काफी हद तक व्यक्तिगत पसंद पर निर्भर करता है जो आपको अधिक पसंद है।

Question 3

Option 1: एक इंट और स्ट्रिंग के साथ एक संरचना की घोषणा करें और एक संरचनात्मक चर लौटाएं।

struct foo {    
 int bar1;
 char bar2[MAX];
};

struct foo fun() {
 struct foo fooObj;
 ...
 return fooObj;
}

Option 2: आप पॉइंटर के माध्यम से दो में से एक को पास कर सकते हैं और पॉइंटर के माध्यम से वास्तविक पैरामीटर में बदलाव कर सकते हैं और दूसरे को हमेशा की तरह वापस कर सकते हैं:

int fun(char **param) {
 int bar;
 ...
 strcpy(*param,"....");
 return bar;
}

या

 char* fun(int *param) {
 char *str = /* malloc suitably.*/
 ...
 strcpy(str,"....");
 *param = /* some value */
 return str;
}

Option 3विकल्प के समान 2. आप सूचक के माध्यम से दोनों को पास कर सकते हैं और फ़ंक्शन से कुछ भी नहीं लौटा सकते हैं:

void fun(char **param1,int *param2) {
 strcpy(*param1,"....");
 *param2 = /* some calculated value */
}

Question 4

चूंकि आपका एक परिणाम प्रकार एक स्ट्रिंग है (और आप सी का उपयोग कर रहे हैं, सी ++ नहीं), मैं आउटपुट पैरामीटर के रूप में पॉइंटर्स पास करने की सलाह देता हूं। उपयोग:

void foo(int *a, char *s, int size);

और इसे इस तरह से कॉल करें:

int a;
char *s = (char *)malloc(100); /* I never know how much to allocate :) */
foo(&a, s, 100);

सामान्य तौर पर, कॉलिंग फ़ंक्शन में आवंटन करना पसंद करते हैं, फ़ंक्शन के अंदर नहीं, ताकि आप अलग-अलग आवंटन रणनीतियों के लिए जितना संभव हो उतना खुला रह सकें।

Question 5

दो अलग-अलग दृष्टिकोण:

पॉइंटर द्वारा अपने रिटर्न मानों को पास करें, और फ़ंक्शन के अंदर उन्हें संशोधित करें। आप अपने कार्य को शून्य घोषित करते हैं, लेकिन यह संकेत के रूप में पारित मूल्यों के माध्यम से लौट रहा है।
एक संरचना को परिभाषित करें जो आपके रिटर्न मूल्यों को एकत्र करता है।

मुझे लगता है कि # 1 थोड़ा अधिक स्पष्ट है कि क्या हो रहा है, हालांकि यदि आपके पास बहुत अधिक रिटर्न मान हैं तो यह थकाऊ हो सकता है। उस स्थिति में, विकल्प # 2 काफी अच्छी तरह से काम करता है, हालांकि इस उद्देश्य के लिए विशेष संरचनाएं बनाने में कुछ मानसिक उपरि शामिल हैं।

Question 6

एक संरचना बनाएं और दो मानों को अंदर सेट करें और संरचना चर वापस करें।

struct result {
    int a;
    char *string;
}

आपको char *अपने कार्यक्रम के लिए जगह आवंटित करनी होगी ।

Question 7

अपने फ़ंक्शन पैरामीटर के रूप में पॉइंटर्स का उपयोग करें। फिर उन्हें कई मान वापस करने के लिए उपयोग करें।

Question 8

फ़ंक्शन के संदर्भ में मापदंडों को पारित करके।

उदाहरण:

 void incInt(int *y)
 {
     (*y)++;  // Increase the value of 'x', in main, by one.
 }

इसके अलावा वैश्विक चर का उपयोग करके, लेकिन यह अनुशंसित नहीं है।

उदाहरण:

int a=0;

void main(void)
{
    //Anything you want to code.
}

Question 9

एक दृष्टिकोण मैक्रोज़ का उपयोग करना है। इसे हेडर फ़ाइल में रखेंmultitype.h

#include <stdlib.h>

/* ============================= HELPER MACROS ============================= */

/* __typeof__(V) abbreviation */

#define TOF(V) __typeof__(V)

/* Expand variables list to list of typeof and variable names */

#define TO3(_0,_1,_2,_3) TOF(_0) v0; TOF(_1) v1; TOF(_2) v2; TOF(_3) v3;
#define TO2(_0,_1,_2)    TOF(_0) v0; TOF(_1) v1; TOF(_2) v2;
#define TO1(_0,_1)       TOF(_0) v0; TOF(_1) v1;
#define TO0(_0)          TOF(_0) v0;

#define TO_(_0,_1,_2,_3,TO_MACRO,...) TO_MACRO

#define TO(...) TO_(__VA_ARGS__,TO3,TO2,TO1,TO0)(__VA_ARGS__)

/* Assign to multitype */

#define MTA3(_0,_1,_2,_3) _0 = mtr.v0; _1 = mtr.v1; _2 = mtr.v2; _3 = mtr.v3;
#define MTA2(_0,_1,_2)    _0 = mtr.v0; _1 = mtr.v1; _2 = mtr.v2;
#define MTA1(_0,_1)       _0 = mtr.v0; _1 = mtr.v1;
#define MTA0(_0)          _0 = mtr.v0;

#define MTA_(_0,_1,_2,_3,MTA_MACRO,...) MTA_MACRO

#define MTA(...) MTA_(__VA_ARGS__,MTA3,MTA2,MTA1,MTA0)(__VA_ARGS__)

/* Return multitype if multiple arguments, return normally if only one */

#define MTR1(...) {                                                           \
    typedef struct mtr_s {                                                    \
      TO(__VA_ARGS__)                                                         \
    } mtr_t;                                                                  \
    mtr_t *mtr = malloc(sizeof(mtr_t));                                       \
    *mtr = (mtr_t){__VA_ARGS__};                                              \
    return mtr;                                                               \
  }

#define MTR0(_0) return(_0)

#define MTR_(_0,_1,_2,_3,MTR_MACRO,...) MTR_MACRO

/* ============================== API MACROS =============================== */

/* Declare return type before function */

typedef void* multitype;

#define multitype(...) multitype

/* Assign return values to variables */

#define let(...)                                                              \
  for(int mti = 0; !mti;)                                                     \
    for(multitype mt; mti < 2; mti++)                                         \
      if(mti) {                                                               \
        typedef struct mtr_s {                                                \
          TO(__VA_ARGS__)                                                     \
        } mtr_t;                                                              \
        mtr_t mtr = *(mtr_t*)mt;                                              \
        MTA(__VA_ARGS__)                                                      \
        free(mt);                                                             \
      } else                                                                  \
        mt

/* Return */

#define RETURN(...) MTR_(__VA_ARGS__,MTR1,MTR1,MTR1,MTR0)(__VA_ARGS__)

यह एक फ़ंक्शन से चार चर तक लौटने और उन्हें चार चर तक असाइन करना संभव बनाता है। एक उदाहरण के रूप में, आप उन्हें इस तरह से उपयोग कर सकते हैं:

multitype (int,float,double) fun() {
    int a = 55;
    float b = 3.9;
    double c = 24.15;

    RETURN (a,b,c);
}

int main(int argc, char *argv[]) {
    int x;
    float y;
    double z;

    let (x,y,z) = fun();

    printf("(%d, %f, %g\n)", x, y, z);

    return 0;
}

यह वह है जो यह प्रिंट करता है:

(55, 3.9, 24.15)

समाधान उतना पोर्टेबल नहीं हो सकता क्योंकि इसके लिए C99 या बाद में वैरिएड मैक्रोज़ और फॉर-स्टेटमेंट वेरिएबल डिक्लेरेशन की आवश्यकता होती है। लेकिन मुझे लगता है कि यहां पोस्ट करना काफी दिलचस्प था। एक और मुद्दा यह है कि संकलक आपको चेतावनी नहीं देगा यदि आप उन्हें गलत मान देते हैं, तो आपको सावधान रहना होगा।

अतिरिक्त उदाहरण, और यूनियनों का उपयोग करके कोड का एक स्टैक-आधारित संस्करण, मेरे गितुब भंडार में उपलब्ध है ।