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

Question

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

int main(){
    char *reply = recvmsg();
    .....
}

我收到警告：

警告 C4172：返回局部变量或临时变量的地址

Answer 1

我建议 std::vector：

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 (如上所示），并回复 C++ API。

底线是：尽可能避免使用new。如果您使用new，那么您必须自己管理它，并且在不需要时delete。

Answer 2

您需要动态分配 char 数组：

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

对于 C++ 和

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

C。

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

Answer 3

警告消息是正确的。您返回的是本地数组的地址，该地址在函数返回后消失。

您可以使用动态内存分配来做到这一点：

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

这避免了内存分配的需要。这实际上是首选方法。

Answer 4

问题是 buffer 存在于堆栈中，并在退出 recvmsg 时超出范围。

您可以在堆上分配缓冲区：

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

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

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

Answer 5

您有几个选择...您现在执行的方式将导致未定义的行为，因为一旦函数返回，数组将超出范围。所以一种选择是动态分配内存。

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

只要记住用这种方式删除它（或者如果使用 malloc 则释放）来清理它。其次，您可以使用参数...

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

同样，这里的清理与之前的清理是一样的。另请注意对 0 的检查，以确保不会对已分配的指针调用 new。

最后，你可以使用向量..

std::vector<char> recmsg()
{
   std::vector<char> temp;

   //do stuff with vector here

   return temp;
}

Answer 6

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

int main(){
    char *reply = recvmsg();
    cout<<reply;
}

Answer 7

只是为了完成图片：

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

所以你可以做的是：

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

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

Answer 8

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

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

void recvmsg(char *buffer, size_t size){

}

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

即使调用者决定动态更好，他们也会知道他们需要释放它，以及执行此操作的具体方法（free（），delete，delete []，或者可能是自定义分配器中的特殊内容）

Answer 9

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

Answer 10

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

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

Answer 11

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

Answer 12

通过 ref 怎么样

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