web-dev-qa-db-ja.com

Cの関数から複数の値を返すにはどうすればよいですか？

結果intと結果stringを生成する関数がある場合、それらを両方とも関数から返すにはどうすればよいですか？

私が知る限り、関数名の前にある型によって決定されるように、1つだけを返すことができます。

creturn-value
78
Tony Stark

あなたのstringが何であるかはわかりませんが、それはそれ自身のメモリを管理すると仮定します。

次の2つのソリューションがあります。

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

どちらを使用するかは、お好みのセマンティクスに関する個人的な好みに大きく依存します。

115
Travis Gockel

Option 1：intと文字列で構造体を宣言し、構造体変数を返します。

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

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

Option 2：ポインタを介して2つのうちの1つを渡し、ポインタを介して実際のパラメータを変更し、通常どおりにもう1つを返すことができます。

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 */
}
10
codaddict

2つの異なるアプローチ：

  1. 戻り値をポインターで渡し、関数内でそれらを変更します。関数をvoidとして宣言しますが、ポインターとして渡された値を介して戻ります。
  2. 戻り値を集約する構造体を定義します。

戻り値が多すぎると退屈になりますが、＃1は何が起こっているかについてもう少し明白だと思います。その場合、オプション2はかなりうまく機能しますが、この目的のための特殊な構造体の作成には精神的なオーバーヘッドが伴います。

6
James Thompson

結果の型の1つが文字列であるため（C++ではなくCを使用しているため）、出力パラメーターとしてポインターを渡すことをお勧めします。つかいます：

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

一般的に、関数自体ではなくcalling関数で割り当てを行うことをお勧めします。これにより、さまざまな割り当て戦略に対して可能な限りオープンにすることができます。

6
Jesse Beder

構造体を作成し、内部に2つの値を設定して、構造体変数を返します。

struct result {
    int a;
    char *string;
}

プログラムのchar *にスペースを割り当てる必要があります。

6
zs2020

関数パラメーターとしてポインターを使用します。次に、それらを使用して複数の値を返します。

3
Bloodlee

関数への参照によってパラメーターを渡すことにより。

例：

 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.
}
2
Badr

1つのアプローチは、マクロを使用することです。これをヘッダーファイルに配置します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__)

これにより、関数から最大4つの変数を返し、最大4つの変数に割り当てることができます。例として、次のように使用できます。

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)

このソリューションは、可変マクロおよびforステートメント変数宣言にC99以降を必要とするため、移植性が低い場合があります。しかし、ここに投稿するのは十分に面白かったと思います。もう1つの問題は、コンパイラに間違った値を割り当てても警告を表示しないため、注意する必要があることです。

追加の例、およびユニオンを使用するスタックベースのコードは、私の githubリポジトリ で入手できます。

2
Klas. S