如何在c++中返回局部数组

我建议std::vector<char>:

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

然后如果你在代码中需要char*，那么你可以随时使用&reply[0]。例如,

void f(const char* data, size_t size) {}
f(&reply[0], reply.size());

你完成了。这意味着，如果您正在使用C API，那么您仍然可以使用std::vector，因为您可以将&reply[0]传递给C API(如上所示)，并将reply传递给c++ API。

底线是:尽可能避免使用new。如果你使用new，那么你必须自己管理它，当你不需要它的时候，你必须使用delete。

你需要动态分配你的字符数组:

char *recvmsg(){
   char* buffer = new char[1024];
   return buffer;
}

用于c++和

char *recvmsg(){
   char* buffer = malloc(1024);
   return buffer;
}

如果没有动态分配，变量将驻留在函数的堆栈中，因此在退出时将被销毁。所以你才会收到警告。在堆上分配它可以防止这种情况，但是您必须小心，并在通过delete[]使用它后释放内存。

提示信息正确。你返回的是一个局部数组的地址，该地址在函数返回后消失。

你可以使用动态内存分配:

char *recvmsg(){
    char *buffer = (char*)malloc(1024);
    return buffer;
}

问题是，您需要确保稍后将该指针free()，以避免内存泄漏。

或者，您可以将缓冲区传递给函数。

void recvmsg(char *buffer,int buffer_size){
    //  write to buffer
}
void main(){
    char buffer[1024];
    recvmsg(buffer,1024);
}

这避免了内存分配的需要。

问题是buffer存在于堆栈中，并且在退出recvmsg的那一刻超出了作用域。

可以在堆上分配buffer:

char *recvmsg(){
  char *buffer = malloc(1024);
  return buffer;
}

注意，现在调用者负责处置分配的内存:

void main(){
  char *reply = recvmsg();
  free(reply);
}

你有几个选择…你现在这样做会导致未定义的行为，因为一旦函数返回，数组就会超出作用域。所以一个选择是动态分配内存..

char * recmsg()
{ 
   char * array = new char[128];
   return array;
}

请记住以这种方式使用delete来清除它(如果使用malloc，则使用free)。第二，可以使用参数…

void recmsg(char * message, int size)
{
   if (message == 0)
      message = new char[size];
}

同样，这里的清理操作与前面的相同。还要注意检查0，以确保您不会在已经分配的指针上调用new。

最后，可以使用vector.

std::vector<char> recmsg()
{
   std::vector<char> temp;
   //do stuff with vector here
   return temp;
}

char *recvmsg(){
    char *buffer = new char;
    cout<<"nENTER NAME : ";
    cin>> buffer;
    return buffer;
}
int main(){
    char *reply = recvmsg();
    cout<<reply;
}

只是为了完成图片:

没有必要用malloc分配内存。您也可以在堆栈上创建缓冲区，但必须在与缓冲区的使用者存活时间相同的堆栈帧上创建它。这是OP的错误——当调用者完成时，缓冲区被删除，调用者得到一个无效的指针。

那么你可以这样做:

void recvmsg(char *buffer, size_t size) {
   ... do what you want ...
}
void main(void) {
    char buffer[1024];
    recvmsg(buffer, sizeof(buffer));
}

可以动态创建缓冲区，但是调用者需要知道如何释放它。

我认为最好传入一个缓冲区(假设recvmsg也填充它)

void recvmsg(char *buffer, size_t size){
}
void main(){
    char buffer[1024];
    recvmsg(buffer, sizeof(buffer));
}

即使调用者认为动态更好，他们也会知道他们需要释放它，以及释放它的具体方法(free()， delete, delete[]，或者可能是自定义分配器的特殊方法)

问题是您正在返回指向堆栈上分配的缓冲区的指针。一旦函数返回，该缓冲区将不再有效。

您正在recvmsg函数内部的堆栈上分配数组。返回指向该内存的指针，如果它被解引用，在某些时候会导致未定义的行为，因为当函数退出时内存将被清理。

如果你想返回一个指向内存的指针，你需要使用malloc动态分配它。

当你返回缓冲区时，它作为指向数组第一个位置的指针，因此它将返回其地址。在你调用函数的地方，你可以创建一个字符指针，它将存储返回的地址值。之后，你可以移动你的指针，并可以访问数组的所有元素。

如何通过ref

char buf[1024];
PutStuffInBuff(&buf);