blocks|key|2930971|text|问题是，当您退出recvmsg时，buffer就存在于堆栈上，并且超出了范围。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2930972|您可以在堆上分配buffer：|2930973|char+*recvmsg(){
++char+*buffer+=+malloc(1024);
++return+buffer;
}|code-block|syntax|javascript|2930974|请注意，调用方现在负责释放分配的内存：|2930975|void+main(){
++char+*reply+=+recvmsg();
++free(reply);
}|2930976|entityMap^0|8|7|H|6|0|8|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

The problem is that <code>buffer</code> lives on the stack and goes out of scope the moment you exit <code>recvmsg</code>.

You could allocate <code>buffer</code> on the heap:

<pre><code>char *recvmsg(){
 char *buffer = malloc(1024);
 return buffer;
}
</code></pre>

Note that now the caller is responsibe for disposing of the allocated memory:

<pre><code>void main(){
 char *reply = recvmsg();
 free(reply);
}
</code></pre>

blocks|key|2931028|text|警告消息是正确的。您返回的是一个本地数组的地址，该数组在函数返回后消失。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2931029|您可以使用动态内存分配来完成此操作：|2931030|char+*recvmsg(){
++++char+*buffer+=+(char*)malloc(1024);
++++return+buffer;
}|code-block|syntax|javascript|2931031|问题是，您需要确保稍后对指针执行free()操作，以避免内存泄漏。|offset|length|style|CODE|2931032|或者，您可以将缓冲区传递给函数。|2931033|void+recvmsg(char+*buffer,int+buffer_size){
++++//++write+to+buffer
}

void+main(){
++++char+buffer[1024];
++++recvmsg(buffer,1024);
}|2931034|这就避免了对内存分配的需要。这实际上是一种更好的方式。|2931035|entityMap^0|0|0|0|G|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|13|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

The warning message is correct. You're returning the address of a local array which disappears after the function returns.

You can do this using dynamic memory allocation:

<pre><code>char *recvmsg(){
 char *buffer = (char*)malloc(1024);
 return buffer;
}
</code></pre>

The catch is that you need to make sure you <code>free()</code> the pointer later on to avoid a memory leak.

Alternatively, you can pass the buffer into the function.

<pre><code>void recvmsg(char *buffer,int buffer_size){
 // write to buffer
}

void main(){
 char buffer[1024];
 recvmsg(buffer,1024);
}
</code></pre>

This avoids the need for a memory allocation. This is actually the preferred way to do it.

blocks|key|2931049|text|问题是返回一个指向堆栈上分配的缓冲区的指针。一旦函数返回，该缓冲区就不再有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2931050|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|$]]

The problem is that you are returning a pointer to a buffer allocated on the stack. Once the function returns, that buffer is no longer valid.

blocks|key|250746|text|您将在recvmsg函数内部的堆栈上分配数组。返回指向该内存的指针将导致未定义的行为，如果它被解除引用，因为当函数退出时内存将被清除。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|250747|如果你想返回一个指向内存的指针，你需要使用malloc动态分配它。|250748|entityMap^0|3|7|0|L|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

You are allocating the array on the stack inside of your <code>recvmsg</code> function. Returning a pointer to that memory will at some point lead to undefined behavior if it is dereferenced as the memory will be cleaned up when the function exits.

If you want to return a pointer to memory you will need to allocate it dynamically using <code>malloc</code>.

blocks|key|249125|text|您需要动态分配char数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|249126|char+*recvmsg(){
+++char*+buffer+=+new+char[1024];
+++return+buffer;
}|code-block|syntax|javascript|249127|对于C%2B%2B和|249128|char+*recvmsg(){
+++char*+buffer+=+malloc(1024);
+++return+buffer;
}|249129|对于C.|249130|发生的情况是，如果没有动态分配，您的变量将驻留在函数的堆栈中，因此在退出时将被销毁。这就是为什么你会收到警告。在堆上分配它可以避免这种情况，但是一旦通过delete[]使用它，您就必须小心并释放内存。|offset|length|style|CODE|249131|entityMap^0|0|0|0|0|0|24|8|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

You need to dynamically allocate your char array:

<pre><code>char *recvmsg(){
 char* buffer = new char[1024];
 return buffer;
}
</code></pre>

for C++ and

<pre><code>char *recvmsg(){
 char* buffer = malloc(1024);
 return buffer;
}
</code></pre>

for C.

What happens is, without dynamic allocation, your variable will reside on the function's stack and will therefore be destroyed on exit. That's why you get the warning. Allocating it on the heap prevents this, but you will have to be careful and free the memory once done with it via <code>delete[]</code>.

blocks|key|3145921|text|您可以动态创建缓冲区，但是调用者需要知道才能释放它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3145922|我认为传入一个缓冲区会更好(假设recvmsg也会填充它)|3145923|void+recvmsg(char+*buffer,+size_t+size){

}

void+main(){
++++char+buffer[1024];
++++recvmsg(buffer,+sizeof(buffer));
}|code-block|syntax|javascript|3145924|即使调用者认为动态更好，他们也会知道他们需要释放它，以及具体的方法(+free+()、delete[]、delete[]，或者可能是来自自定义分配器的特殊方法)|3145925|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You could dynamically create the buffer, but then the caller needs to know to free it.

I think it's better to pass in a buffer (assuming recvmsg also fills it)

<pre><code>void recvmsg(char *buffer, size_t size){

}

void main(){
 char buffer[1024];
 recvmsg(buffer, sizeof(buffer));
}
</code></pre>

Even if the caller decides dynamic is better, they will know that they need to free it, and the specific way to do that (free(), delete, delete[], or perhaps something special from a custom allocator)

blocks|key|249157|text|我建议使用std::vector<char>|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|249158|std::vector<char>+recvmsg()
{
++++std::vector<char>+buffer(1024);
++++//..
++++return+buffer;
}
int+main()
{
++++std::vector<char>+reply+=+recvmsg();
}|code-block|syntax|javascript|249159|然后，如果您的代码中需要char*，那么您可以随时使用&reply[0]。例如,|249160|void+f(const+char*+data,+size_t+size)+{}

f(&reply[0],+reply.size());|249161|你就完事了。这意味着，如果您正在使用can，那么您仍然可以使用std::vector，因为您可以将&reply[0]传递给can+(如上所示)，将reply传递给C%2B%2B+API。|249162|底线是:尽量避免使用new。如果你使用new，那么你必须自己管理它，当你不需要它的时候，你必须使用delete。|249163|entityMap^0|5|H|0|0|C|5|R|9|0|0|V|B|1D|9|21|5|0|A|3|J|3|1D|6|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|T|$]]

I would suggest <code>std::vector&lt;char&gt;</code>:

<pre><code>std::vector&lt;char&gt; recvmsg()
{
 std::vector&lt;char&gt; buffer(1024);
 //..
 return buffer;
}
int main()
{
 std::vector&lt;char&gt; reply = recvmsg();
}
</code></pre>

And then if you ever need <code>char*</code> in your code, then you can use <code>&amp;reply[0]</code> anytime you want. For example,

<pre><code>void f(const char* data, size_t size) {}

f(&amp;reply[0], reply.size());
</code></pre>

And you're done. That means, if you're using C API, then you can still use <code>std::vector</code>, as you can pass <code>&amp;reply[0]</code> to the C API (as shown above), and <code>reply</code> to C++ API.

The bottomline is : avoid using <code>new</code> as much as possible. If you use <code>new</code>, then you've to manage it yourself, and you've to <code>delete</code> when you don't need it.

blocks|key|2931256|text|你有一些options...The的方法，你现在这样做会导致未定义的行为，因为一旦函数返回，数组就会超出作用域。因此，一种选择是动态分配内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2931257|char+*+recmsg()
{+
+++char+*+array+=+new+char[128];
+++return+array;
}|code-block|syntax|javascript|2931258|只需记住使用delete+this方法(如果使用malloc，则使用free+)来清理它。其次，你可以使用一个参数...|2931259|void+recmsg(char+*+message,+int+size)
{
+++if+(message+==+0)
++++++message+=+new+char[size];
}|2931260|同样，这里的清理也与上一次一样。还要注意对0的检查，以确保您不会在已经分配的指针上调用new。|2931261|最后，你可以使用一个向量..|2931262|std::vector<char>+recmsg()
{
+++std::vector<char>+temp;

+++//do+stuff+with+vector+here

+++return+temp;
}|2931263|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You have a few options...The way you're doing it now is going to cause undefined behavior as the array will go out of scope once hte function returns. So one option is to dynamically allocate the memory..

<pre><code>char * recmsg()
{ 
 char * array = new char[128];
 return array;
}
</code></pre>

Just remember to clean it up with delete this way (or free if you used malloc). Second, you could use a parameter...

<pre><code>void recmsg(char * message, int size)
{
 if (message == 0)
 message = new char[size];
}
</code></pre>

Again, the same thing goes for clean up here as with the previous. Also note the check for 0 to make sure you don't call new on a pointer that's been allocated already.

Last, you could use a vector..

<pre><code>std::vector&lt;char&gt; recmsg()
{
 std::vector&lt;char&gt; temp;

 //do stuff with vector here

 return temp;
}
</code></pre>

blocks|key|2931297|text|当你返回buffer时，因为它是指向数组第一个位置的指针，所以它会返回它的address.And，也就是你调用函数的地方，你可以创建一个字符指针，它将存储这个返回的地址值.After，你可以移动指针，访问数组的所有元素。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2931298|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|$]]

when you are returning the buffer then as it acting as a pointer to the first location of the array so it will return its address.And the place where you are calling the function there you can make a character pointer which will store this returned address value .After which you can move your pointer and can access all the elements of your array.

blocks|key|250826|text|char+*recvmsg(){
++++char+*buffer+=+new+char;
++++cout<<"\nENTER+NAME+:+";
++++cin>>+buffer;
++++return+buffer;
}

int+main(){
++++char+*reply+=+recvmsg();
++++cout<<reply;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|250827|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>char *recvmsg(){
 char *buffer = new char;
 cout&lt;&lt;"\nENTER NAME : ";
 cin&gt;&gt; buffer;
 return buffer;
}

int main(){
 char *reply = recvmsg();
 cout&lt;&lt;reply;
}
</code></pre>

blocks|key|3146099|text|用ref传球怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3146100|char+buf[1024];
PutStuffInBuff(&buf);|code-block|syntax|javascript|3146101|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

how about passing by ref

<pre><code>char buf[1024];
PutStuffInBuff(&amp;buf);
</code></pre>

blocks|key|254209|text|为了完成这幅图：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|254210|不需要使用malloc来分配内存。您也可以在堆栈上创建缓冲区，但必须在堆栈帧上创建它，只要缓冲区的使用者存在，它就会一直存在。这就是操作的错误--当被调用者完成时，缓冲区被删除，调用者得到一个无效的指针。|254211|所以你能做的是：|254212|void+recvmsg(char+*buffer,+size_t+size)+{
+++...+do+what+you+want+...
}

void+main(void)+{
++++char+buffer[1024];
++++recvmsg(buffer,+sizeof(buffer));
}|code-block|syntax|javascript|254213|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just to complete the picture:

It is not necessary, to allocate memory with malloc. You can also create the buffer on the stack, but you must create it on a stack frame that lives as long as the consumer of the buffer lives. That was the error of the OP -- when the callee was finished, the buffer was deleted and the caller got a invalid pointer.

So what you can do is this:

<pre><code>void recvmsg(char *buffer, size_t size) {
 ... do what you want ...
}

void main(void) {
 char buffer[1024];
 recvmsg(buffer, sizeof(buffer));
}
</code></pre>

<pre><code>char *recvmsg(){
 char buffer[1024];
 return buffer;
}

int main(){
 char *reply = recvmsg();
 .....
}
</code></pre>

I get a warning:

<blockquote>
 warning C4172: returning address of local variable or temporary
</blockquote>

How to return local array in C++?

char *recvmsg(){    char buffer[1024];    return buffer;}int main(){    char *reply = recvmsg();    .....}我得到一个警告：警告C4172:返回局部变量或临时的地址

问如何在C++中返回本地数组？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中返回本地数组？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C++中返回本地数组？
EN