blocks|key|3962780|text|第一个版本在堆栈上分配对象，并返回该对象的副本。第二个版本在Java堆上创建对象，并返回一个指向它的指针(除了内存不会自动释放之外，这与引用最接近)。您不应该忘记稍后在返回的指针上调用free()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|3962781|顺便说一句，你的main函数不好。它应该是|3962782|int+main(void)
{++++
++++...
++++return+0;
}|code-block|syntax|javascript|3962783|我建议你应该读一读a+good+C+book。这是你要问的最基本的问题。|3962784|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/562303/the-definitive-c-book-guide-and-list^0|6|2|L|2|1E|2|1W|V|2K|6|0|0|L|0|0|0|10|9|D|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|18|8|@$9|19|A|1A|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1B|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|E|@$9|1F|A|1G|1|1H]]|F|$]]|$1|P|3|-4|5|6|7|1I|8|@]|E|@]|F|$]]]|Q|$R|$5|S|T|U|F|$V|W]]]]

The first version allocates the object on the stack and returns a copy of it. The second version creates the object on the heap and returns a pointer to it(this is closest to Java references except that the memory isn't automatically freed). You should not forget to call <code>free()</code> later on the returned pointer.

Btw, your main function is bad. It should be

<pre><code>int main(void)
{ 
 ...
 return 0;
}
</code></pre>

I suggest that you should read <a href="https://stackoverflow.com/questions/562303/the-definitive-c-book-guide-and-list">a good C book</a>. This is really basic stuff you're asking.

blocks|key|405452|text|两者都是合法的，都是有效的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|405453|第一个版本更简单，您不必处理内存分配和释放。|405454|对于更大的结构，第二个版本的性能会更好，因为您避免了将整个结构放在堆栈上进行移交。|405455|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Both are legal, both work.

The 1st version is simpler, you avoid having to deal with memory allocation and releasing.

The 2nd version will perform better for bigger structs because you avoid putting the whole struct on stack for handing it over.

blocks|key|2348231|text|第一个函数分配堆栈上的变量。myfunction中的person对象是从函数中复制并返回的，效率较低，但不会出现内存泄漏。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2348232|第二个示例返回一个指向动态分配(使用malloc)的person对象的指针(+*)。由malloc分配的person对象永远不会被销毁，除非你显式地调用free()，而你没有这样做--所以你有一个内存泄漏。|2348233|你需要在C中显式地释放内存，它没有像Java那样的垃圾回收。|2348234|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The first one allocates the variables on the stack. The person object from myfunction is copied from the function and returned which is less efficient, but you can't get a memory leak which is good.

The second example returns a pointer (the *) to a person object that is dynamically allocated (with malloc). The person object allocated by malloc will never be destroyed unless you explicitly call free() on it, hwich you haven't - so you have a memory leak.

You need to explicitly free memory in C, it doesn't have garbage-collection like Java.

blocks|key|405505|text|第一个方法将在堆栈上分配一个struct+person，并将其副本传回，然后释放原始文件。第二个将在堆上分配它，并传递一个指向分配的位置的指针，并且不会释放它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|405506|entityMap^0|E|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

The first will allocate a <code>struct person</code> on the stack, and pass a copy of it back, then free the original. The second one will allocate it on the heap and pass a pointer to the location which was allocated, and will not free it.

blocks|key|2348343|text|第一个代码示例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2348344|在堆栈上的myfunction()中创建一个结构并返回它。然后，创建另一个堆栈结构，并将第一个堆栈结构到第二个堆栈结构。第一个是被摧毁的。当您超出范围时，第二个将被自动销毁。|2348345|实际创建的是2结构。|2348346|第二个代码示例：|2348347|在myfunction()中创建一个结构，然后只复制地址。main中的struct实际上是同一个struct。|2348348|这里只创建了一个结构体。|2348349|这两个代码示例都可以工作，但对于后一种情况，您必须显式地释放为结构分配的内存，以避免内存泄漏，但性能应该更好，因为您不需要复制结构！|2348350|编辑：|2348351|正如@Mat所提到的:这当然忽略了malloc()的开销，这对于小的结构是不正确的。|2348352|entityMap^0|0|8|0|0|6|3|0|0|8|0|0|0|P|D|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|17|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|18|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|1F|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|W|$]]

first code sample:
 you create a struct in myfunction() on your stack and return it. then, you create another stack struct, and you copy the first to the second. the first is destroyed. the second will be automatically destroyed when you are out of the scope.
 2 structs were actually created.

second code sample:
 you create a struct in myfunction(), and then you copy only the address. the struct in main will actually be the same struct.
 only one struct is created in here.

both code samples work, but for the later you will have to explicitly free the memory allocated for the struct, to avoid memory leak, but performance should be better since you don't need to copy the struct!

EDIT:
 as mentioned by @Mat: this of course neglects the overhead of malloc(), which is not true for small structs.

blocks|key|405558|text|第一个选项在堆栈上创建一个结构，当返回它时，它被复制到在main()函数中定义的结构中。还复制了字段。对于较大的结构，这可能是一个代价高昂的操作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|405559|第二个选项分配动态内存，当您返回它时不会复制它。您必须对指针执行free()操作以避免内存泄漏。|405560|当然，这取决于您的需求，但对于更重要、寿命更长的对象，我会选择第二种选择。另外，我建议编写分配/初始化函数和相应的释放函数。(请参阅下面的原因)|405561|问题是您在myfunction()中设置的2个字符串在函数外部是无效的，因为它们也是在堆栈上创建的。您必须使用strdup()或类似的函数来进行此故障保存。当然，为了不让内存泄漏，您必须对strduped指针执行free()操作，就像malloc()一样。|405562|entityMap^0|S|6|0|W|6|0|0|5|C|1J|8|2M|6|2Y|6|39|8|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|M|$]]

The first option creates a struct on the stack, when returning it, it gets copied to your struct defined in the <code>main()</code> function. Also copied are the fields. For larger structs this can be a costly operation.

The second option allocates dynamic memory, which does not get copied when you return it. You have to <code>free()</code> the pointer to avoid a memory leak.

Of course it depends on your needs, but for more important and long living objects I'd go for the second option. Also I would recommend to write allocation/initialization functions and a corresponding deallocation function. (see below why)

The problem is that the 2 strings you set in <code>myfunction()</code> are invalid outside of the function, as they are also created on the stack. You have to use <code>strdup()</code> or a similar function to make this failsave. Of course, to not let memory leaks slip in you have to <code>free()</code> the <code>strdup</code>ed pointers, just as with <code>malloc()</code>.

blocks|key|3963068|text|在第一段代码中，myPerson是一个struct+person类型的对象，由实现本身管理(*)。在第二段代码中，它是一个struct+person+*类型的对象(指向struct+person的指针)。在第二段代码中，对象本身必须由程序员管理(malloc、realloc、free)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3963069|此外，在第一个代码中，对象本身被复制了几次，而在第二个代码中，“只”复制了指针。通常，指针比结构类型的对象小得多。|3963070|使用第二种方法，但要记住使用free对象。|3963071|更好的方法是，在父函数中创建对象并将指针传递给函数：sruct+person+*myfunction(struct+person+*data)+{+/*+...+*/+}|3963072|(*)关于对象管理，我指的是创建和删除对象的时间等等|3963073|entityMap^0|8|8|J|D|1P|F|2C|D|3F|6|3M|7|3U|4|0|0|E|4|0|Q|1N|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1B|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|O|$]]

In the first code, <code>myPerson</code> is an object of type <code>struct person</code> that is managed (*) by the implementation itself. In the second code, it is an object of type <code>struct person *</code> (a pointer to a <code>struct person</code>). In the second code, the object itself must be managed by the programmer (<code>malloc</code>, <code>realloc</code>, <code>free</code>).

Also, in the first code, the object itself is copied around a few times whereas in the 2nd code "only" the pointer gets copied. Usualy a pointer is much smaller than an object of a struct type.

Use the 2nd approach but remember to <code>free</code> the object.

Even better, create the object in the parent function and pass a pointer to functions: <code>sruct person *myfunction(struct person *data) { /* ... */ }</code>

(*) with object management I mean the time it gets created and deleted and stuff

blocks|key|405622|text|我不确定所有这些关于“堆”和“栈”的讨论是否切入了语言的核心，所以让我尝试一些更具语言本质的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|405623|您的第一个版本仅使用自动分配，这意味着所有变量都具有自动生存期。也就是说，所有变量在其封闭作用域的末尾结束其生命周期：myFunction创建一个struct+person类型的局部变量并返回该变量的副本；main函数声明一个相同类型的局部变量，并将函数调用的结果赋给它。在每个作用域的末尾，局部变量也会结束。|offset|length|style|CODE|405624|第二个版本使用动态或手动分配。使用malloc()调用显式地为person变量分配存储空间，该存储空间将保持已分配状态，直到有人(通过free())解除分配。由于您从未释放它，这实际上是一个内存泄漏。|405625|根本的区别是终生和责任的区别。|405626|一些利弊:自动分配意味着责任是本地的，你通常不必担心任何事情。然而，它的代价是必须复制参数并按值返回值，这可能是昂贵的或不受欢迎的。手动分配允许您通过简单、廉价的指针引用大量内存，并且通常是实现某些构造的唯一方法，但需要让作者记住谁负责哪些资源。|405627|entityMap^0|0|1N|A|21|D|2V|4|0|H|8|V|6|1V|6|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|15|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|O|$]]

I'm not sure if all this talk of "heap" and "stack" is cutting to the core of the language, so let me try something more language-intrinsic.

Your first version uses only automatic allocation, which means that all variables have automatic lifetime. That is, all variables end their life at the end of their enclosing scope: <code>myFunction</code> creates a local variable of type <code>struct person</code> and returns a copy of that variable; the <code>main</code> function declares a local variable of the same type and assigns to it the result of the function call. At the end of each scope, the local variables end as well.

The second version uses dynamic or manual allocation. You explicitly allocate storage for a <code>person</code> variable with the <code>malloc()</code> call, and that storage will remain allocated until someone deallocates is (via <code>free()</code>). Since you never deallocate it, this is in effect a memory leak.

The fundamental difference is one of lifetime and responsibility.

A few pros and cons: Automatic allocation means that responsibility is local, and you generally don't have to worry about anything. However, it comes at the price of having to copy arguments and return values by value, which may be expensive or undesirable. Manual allocation allows you to refer to large amounts of memory via a simple, cheap pointer, and is often the only way to implement certain constructions, but carries the burden of having the author remember who's responsible for which resource.

blocks|key|2348512|text|实际上，我会选择第三种方式。让调用者考虑如何提供存储空间(自动或动态分配)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2348513|void+myfunction(struct+person*+myPerson)
{
+++++myPerson->firstname+=+"John";
+++++myPerson->lastname+=+"Doe";
}|code-block|syntax|javascript|2348514|可以使用自动或动态分配的变量调用该函数：|2348515|struct+person+autoperson;
myfunction(&person);

struct+person+dynamic_person+=+malloc(sizeof+struct+person);
myfunction+dynamic_person);|2348516|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I would actually choose a third way. Let the caller worry about providing storage space (auto or dynamically allocated):

<pre><code>void myfunction(struct person* myPerson)
{
 myPerson-&gt;firstname = "John";
 myPerson-&gt;lastname = "Doe";
}
</code></pre>

The function can be called either with an automatically or dynamically allocated variable:

<pre><code>struct person autoperson;
myfunction(&amp;person);

struct person dynamic_person = malloc(sizeof struct person);
myfunction dynamic_person);
</code></pre>

blocks|key|405647|text|第一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|405648|main()
{
++++//+create+a+person+struct+on+the+stack
++++struct+person+myperson;
++++//+copy+the+struct+returned+by+myfunction+to+myperson.
++++myperson+=+myfunction();
}

struct+person+myfunction()
{
++++//+create+a+person+struct+on+the+stack.
++++struct+person+myPerson;
++++myPerson.firstname+=+"John";
++++myPerson.lastname+=+"Doe";
++++//+return+the+myPerson+struct.+After+myFunction+returns,+the+memory
++++//+holding+the+myPerson+struct+on+the+stack+will+be+freed.
++++return+myPerson;
}|code-block|syntax|javascript|405649|第二个：|405650|main()
{
++++//+create+a+pointer+to+a+person+struct+on+the+stack
++++struct+person+*myperson;
++++//+assign+the+pointer+returned+by+myfunction+to+myperson
++++myperson+=+myfunction();
}

struct+person*+myfunction()
{
++++//+create+a+pointer+to+a+person+struct+on+the+stack
++++struct+person+*myPerson;
++++//+allocate+memory+for+a+person+struct+in+dynamic+memory+and+set+myPerson
++++//+to+point+to+that+memory.+This+memory+will+remain+valid+until+it's+freed+by
++++//+a+call+to+the+"free"+function.+Using+malloc+is+much+slower+than+creating
++++//+an+object+on+the+stack.+There+is+also+the+added+performance+cost+of
++++//+freeing+the+allocated+memory+at+a+later+stage.
++++myPerson+=+malloc(sizeof(struct+person));++
++++myPerson->firstname+=+"John";
++++myPerson->lastname+=+"Doe";
++++//+return+the+myPerson+pointer
++++return+myPerson;
}|405651|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

First One:

<pre><code>main()
{
 // create a person struct on the stack
 struct person myperson;
 // copy the struct returned by myfunction to myperson.
 myperson = myfunction();
}

struct person myfunction()
{
 // create a person struct on the stack.
 struct person myPerson;
 myPerson.firstname = "John";
 myPerson.lastname = "Doe";
 // return the myPerson struct. After myFunction returns, the memory
 // holding the myPerson struct on the stack will be freed.
 return myPerson;
}
</code></pre>

Second one:

<pre><code>main()
{
 // create a pointer to a person struct on the stack
 struct person *myperson;
 // assign the pointer returned by myfunction to myperson
 myperson = myfunction();
}

struct person* myfunction()
{
 // create a pointer to a person struct on the stack
 struct person *myPerson;
 // allocate memory for a person struct in dynamic memory and set myPerson
 // to point to that memory. This memory will remain valid until it's freed by
 // a call to the "free" function. Using malloc is much slower than creating
 // an object on the stack. There is also the added performance cost of
 // freeing the allocated memory at a later stage.
 myPerson = malloc(sizeof(struct person)); 
 myPerson-&gt;firstname = "John";
 myPerson-&gt;lastname = "Doe";
 // return the myPerson pointer
 return myPerson;
}
</code></pre>

I am a java programmer learning C. Have a question regaring functions. What are the differences between this:

<pre><code>main()
{
 struct person myperson;

 myperson = myfunction();

 return;
}

struct person myfunction()
{
 struct person myPerson;
 myPerson.firstname = "John";
 myPerson.lastname = "Doe";
 return myPerson;
}
</code></pre>

VS

<pre><code>main()
{
 struct person *myperson;

 myperson = myfunction();

 return;
}

struct person* myfunction()
{
 struct person *myPerson;
 myPerson = malloc(sizeof(struct person));
 myPerson-&gt;firstname = "John";
 myPerson-&gt;lastname = "Doe";
 return myPerson;
}
</code></pre>

Are these legal in C? And y would 1 choose one over the other.
Thanks so much guys!

question regarding return functions in C

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我是一个学习C ++的java程序员，有一个关于函数的问题。这两者之间有什么区别：main(){    struct person myperson;    myperson = myfunction();    return;}struct person myfunction(){     struct person...

问关于C语言中返回函数的问题
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问关于C语言中返回函数的问题EN