Возврат по полученному массиву char [duplicate]

как насчет прохождения по ref

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

Вы выделяете массив в стек внутри вашей функции recvmsg. Возврат указателя на эту память в какой-то момент приведет к неопределенному поведению, если он будет разыменован, так как память будет очищена, когда функция выйдет.

Если вы хотите вернуть указатель в память, вам нужно будет распределите его динамически, используя malloc.

Просто для завершения изображения:

Нет необходимости выделять память с помощью 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 [] или, возможно, что-то особенное из пользовательского распределителя)

У вас есть несколько вариантов ... То, как вы сейчас это делаете, приведет к неопределенному поведению, поскольку массив выйдет из области действия после возврата функции hte. Таким образом, один из вариантов заключается в динамическом распределении памяти.

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

Не забудьте очистить его удалением таким образом (или бесплатно, если вы использовали malloc). Во-вторых, вы можете использовать параметр ...

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

Опять же, то же самое происходит для очистки здесь, как и с предыдущим. Также обратите внимание на проверку на наличие 0, чтобы убедиться, что вы не вызываете новый указатель, который уже был выделен.

Наконец, вы можете использовать вектор.

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

   //do stuff with vector here

   return temp;
}

Предупреждающее сообщение верное. Вы возвращаете адрес локального массива, который исчезает после возвращения функции.

Вы можете сделать это, используя распределение динамической памяти:

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

Это позволяет избежать необходимости выделение памяти. Это действительно предпочтительный способ сделать это.

Я бы предложил 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, когда вам это не понадобится.