blocks|key|329749|text|创建一个struct并在其中设置两个值，然后返回struct变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329750|struct+result+{
++++int+a;
++++char+*string;
}|code-block|syntax|javascript|329751|你必须在你的程序中为char+*分配空间。|offset|length|style|CODE|329752|entityMap^0|0|0|A|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Create a struct and set two values inside and return the struct variable.

<pre><code>struct result {
 int a;
 char *string;
}
</code></pre>

You have to allocate space for the <code>char *</code> in your program.

blocks|key|1074298|text|使用指针作为函数参数。然后使用它们返回多个值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1074299|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Use pointers as your function parameters.
Then use them to return multiple value.

blocks|key|328788|text|我不知道你的string是什么，但我假设它管理着自己的内存。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|328789|您有两种解决方案：|328790|1:返回一个包含所有需要的类型的struct。|328791|struct+Tuple+{
++++int+a;
++++string+b;
};

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

void+foo()+{
++++struct+Tuple+t+=+getPair();
}|code-block|syntax|javascript|328792|2:使用指针传出值。|328793|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);
}|328794|您选择使用哪一种语义在很大程度上取决于个人偏好，即您更喜欢哪种语义。|328795|entityMap^0|6|6|0|0|G|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

I don't know what your <code>string</code> is, but I'm going to assume that it manages its own memory.

You have two solutions:

1: Return a <code>struct</code> which contains all the types you need.

<pre><code>struct Tuple {
 int a;
 string b;
};

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

void foo() {
 struct Tuple t = getPair();
}
</code></pre>

2: Use pointers to pass out values.

<pre><code>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(&amp;a, &amp;b);
}
</code></pre>

Which one you choose to use depends largely on personal preference as to whatever semantics you like more.

blocks|key|3028965|text|两种不同的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3028966|3028967|通过指针传入返回值，并在函数内部修改返回值。您声明您的函数为void，但它通过作为指针传递的值返回。|ordered-list-item|3028968|定义了一个聚合返回值的结构。|3028969|3028970|我认为#1对正在发生的事情更明显一些，尽管如果你有太多的返回值，它可能会变得单调乏味。在这种情况下，选项#2工作得相当好，尽管为此目的创建专门的结构需要一些心理开销。|3028971|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|N|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|P|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|L|$]]

Two different approaches:

<ol>
<li>Pass in your return values by pointer, and modify them inside the function. You declare your function as void, but it's returning via the values passed in as pointers. </li>
<li>Define a struct that aggregates your return values. </li>
</ol>

I think that #1 is a little more obvious about what's going on, although it can get tedious if you have too many return values. In that case, option #2 works fairly well, although there's some mental overhead involved in making specialized structs for this purpose.

blocks|key|1620557|text|由于您的结果类型之一是字符串(并且您使用的是C，而不是C%2B%2B)，因此我建议将指针作为输出参数进行传递。使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1620558|void+foo(int+*a,+char+*s,+int+size);|code-block|syntax|javascript|1620559|然后这样叫它：|1620560|int+a;
char+*s+=+(char+*)malloc(100);+/*+I+never+know+how+much+to+allocate+:)+*/
foo(&a,+s,+100);|1620561|一般来说，更喜欢在调用函数中进行分配，而不是在函数本身内部进行分配，这样您就可以尽可能地开放不同的分配策略。|1620562|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Since one of your result types is a string (and you're using C, not C++), I recommend passing pointers as output parameters. Use:

<pre><code>void foo(int *a, char *s, int size);
</code></pre>

and call it like this:

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

In general, prefer to do the allocation in the calling function, not inside the function itself, so that you can be as open as possible for different allocation strategies.

blocks|key|3029059|text|Option+1：声明一个带有整数和字符串的结构，并返回一个结构变量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3029060|struct+foo+{++++
+int+bar1;
+char+bar2[MAX];
};

struct+foo+fun()+{
+struct+foo+fooObj;
+...
+return+fooObj;
}|code-block|syntax|javascript|3029061|Option+2：您可以通过指针传递两个参数中的一个，并通过指针更改实际参数，然后像往常一样返回另一个：|3029062|int+fun(char+**param)+{
+int+bar;
+...
+strcpy(*param,"....");
+return+bar;
}|3029063|或|3029064|+char*+fun(int+*param)+{
+char+*str+=+/*+malloc+suitably.*/
+...
+strcpy(str,"....");
+*param+=+/*+some+value+*/
+return+str;
}|3029065|Option+3：类似于选项2。可以通过指针传递，也可以不从函数返回任何内容：|3029066|void+fun(char+**param1,int+*param2)+{
+strcpy(*param1,"....");
+*param2+=+/*+some+calculated+value+*/
}|3029067|entityMap^0|0|8|0|0|0|8|0|0|0|0|0|8|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|X|$]]

<code>Option 1</code>: Declare a struct with an int and string and return a struct variable.

<pre><code>struct foo { 
 int bar1;
 char bar2[MAX];
};

struct foo fun() {
 struct foo fooObj;
 ...
 return fooObj;
}
</code></pre>

<code>Option 2</code>: You can pass one of the two via pointer and make changes to the actual parameter through the pointer and return the other as usual:

<pre><code>int fun(char **param) {
 int bar;
 ...
 strcpy(*param,"....");
 return bar;
}
</code></pre>

or

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

<code>Option 3</code>: Similar to the option 2. You can pass both via pointer and return nothing from the function:

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

blocks|key|3029080|text|通过引用将参数传递给函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3029081|示例：|3029082|+void+incInt(int+*y)
+{
+++++(*y)%2B%2B;++//+Increase+the+value+of+'x',+in+main,+by+one.
+}|code-block|syntax|javascript|3029083|也可以使用全局变量，但不推荐这样做。|3029084|3029085|int+a=0;

void+main(void)
{
++++//Anything+you+want+to+code.
}|3029086|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|S|8|@]|9|@]|A|$]]|$1|K|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

By passing parameters by reference to function.

Examples:

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

Also by using global variables but it is not recommended.

Example:

<pre><code>int a=0;

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

blocks|key|328935|text|一种方法是使用宏。将其放在头文件multitype.h中|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|328936|#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%2B%2B)+++++++++++++++++++++++++++++++++++++++++\
++++++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__)|code-block|syntax|javascript|328937|这使得从函数中返回最多四个变量，并将它们分配给最多四个变量成为可能。例如，您可以像这样使用它们：|328938|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("(%25d,+%25f,+%25g\n)",+x,+y,+z);

++++return+0;
}|328939|下面是它打印的内容：|328940|(55,+3.9,+24.15)|328941|该解决方案可能不具有可移植性，因为它需要C99或更高版本的变量宏和for语句变量声明。但我认为在这里发布它已经足够有趣了。另一个问题是，如果你给它们赋了错误的值，编译器不会警告你，所以你必须小心。|328942|我的github+repository上提供了其他示例以及使用联合的基于堆栈的代码版本。|328943|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/klassegeljakt/MacroMagic/tree/master/multitype^0|G|B|0|0|0|0|0|0|0|2|H|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1C|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1D|8|@]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|W|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

One approach is to use macros. Place this in a header file <code>multitype.h</code>

<pre><code>#include &lt;stdlib.h&gt;

/* ============================= 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 &lt; 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__)
</code></pre>

This makes it possible to return up to four variables from a function and assign them to up to four variables. As an example, you can use them like this:

<pre><code>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;
}
</code></pre>

This is what it prints:

<pre><code>(55, 3.9, 24.15)
</code></pre>

The solution may not be as portable because it requires C99 or later for variadic macros and for-statement variable declarations. But I think it was interesting enough to post here. Another issue is that the compiler will not warn you if you assign them the wrong values, so you have to be careful.

Additional examples, and a stack-based version of the code using unions, are available at my <a href="https://github.com/klassegeljakt/MacroMagic/tree/master/multitype" rel="nofollow noreferrer">github repository</a>.

If I have a function that produces a result <code>int</code> and a result <code>string</code>, how do I return them both from a function?

As far as I can tell I can only return one thing, as determined by the type preceding the function name.

How do I return multiple values from a function in C?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果我有一个生成结果int和结果string的函数，我如何从函数中返回这两个结果？据我所知，我只能返回一个东西，这是由函数名前面的类型决定的。

问如何在C中从一个函数返回多个值？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C中从一个函数返回多个值？EN