将返回值从函数存储到指向char变量的指针中是正确的做法吗？

Question

我编写了一个读取功能，该功能从串行端口（LINUX）读取值。 它返回值作为char的指针。 我在另一个函数中调用此函数，并将其再次存储在变量中作为char的指针。 我偶尔遇到堆栈溢出问题，不确定该函数是否引起问题。 下面提供了示例。 请给我一些建议或批评。

    char *ReadToSerialPort( )
    {
         const int buffer_size = 1024;
         char *buffer = (char *)malloc(buffer_size);
         char *bufptr = buffer;
         size_t iIn;
         int iMax = buffer+buffer_size-bufptr;

           if ( fd < 1 )
           {
            printf( "port is not open\n" );
           // return -1;
           }
           iIn = read( fd, bufptr, iMax-1 );
           if ( iIn < 0 )
           {
             if ( errno == EAGAIN )
             {
                printf( "The errror in READ" );
                return 0; // assume that command generated no response
             }
             else
                printf( "read error %d %s\n", errno, strerror(errno) );
          }
         else
          {
           // *bufptr = '\0';
           bufptr[(int)iIn<iMax?iIn:iMax] = '\0';
           if(bufptr != buffer)
               return bufptr;
         }
        free(buffer);
       return 0;

} // end ReadAdrPort

int ParseFunction(void)
{
     // some other code
     char *sResult;

    if( ( sResult = ReadToSerialPort()) >= 0)
   {
      printf("Response is %s\n", sResult);

     // code to store char in string and put into db .
   }

}

谢谢和问候，SamPrat

Answer 1

您不取消分配缓冲区。 使用完后需要free 。

char * getData()
{
    char *buf = (char *)malloc(255);
    // Fill buffer
    return buf;
}

void anotherFunc()
{
    char *data = getData();
    // Process data
    free(data);
}

就您而言，我认为您应该在printf之后释放缓冲区：

if( ( sResult = ReadToSerialPort()) >= 0)
{
   printf("Response is %s\n", sResult);

   // code to store char in string and put into db .

   free(sResult);
}

UPDATE静态缓冲区

使用静态缓冲区的另一种选择。 它可以稍微提高性能，但是getData方法不是线程安全的。

char buff[1024];

char *getData()
{
    // Write data to buff
    return buff;
}

int main()
{
    char *data = getData();
    printf("%s", data);
}

更新有关代码的一些注意事项

1. int iMax = buffer+buffer_size-bufptr; -iMax始终为1024；
2. 我看不到使用bufptr任何想法，因为它的值与buffer相同，并且您不会在函数中的任何位置进行更改。
3. iIn = read( fd, bufptr, buffer_size-1 );
4. 您可以替换bufptr[(int)iIn<iMax?iIn:iMax] = '\\0'; 与bufptr[iIn] = '\\0' ;
5. if(bufptr != buffer)始终为false ，这就是为什么指针不正确并且始终返回0的原因；
6. 如果errno == EAGAIN为true，请不要忘记释放缓冲区。 当前，您只返回0而没有free(buffer) 。

祝好运 ;）

Answer 2

Elalfer是部分正确的。 您可以使用free（）缓冲区，但并非在每种情况下都可以。

例如，当您到达if ( errno == EAGAIN )并且其结果为true时，您return而free对缓冲区进行free操作。

最好的方法是将缓冲区作为参数传递，并明确表明用户必须在函数外部释放缓冲区。 （这基本上是Elalfer在他的编辑答案中所说的）。

刚意识到这是一个C问题，对此我要怪SO过滤：D对不起！ 忽略以下内容，我将其保留，以便使注释仍然有意义。

正确的解决方案应使用std::vector<char> ，这样析构函数将在作用域末尾为您处理内存释放。

Answer 3

第二个指针的目的是什么？

char *buffer = (char *)malloc(buffer_size);
char *bufptr = buffer;

这样做的目的是什么？

int iMax = buffer+buffer_size-bufptr; // eh? 

这样做的目的是什么？

bufptr[(int)iIn<iMax?iIn:iMax] = '\0'; // so you pass in 1023 (iMax - 1), it reads 1023, you've effectively corrupted the last byte.

我将重新开始，考虑使用std::vector<char> ，类似于：

std::vector<char> buffer(1500); // default constructs 1500 chars

int iRead = read(fd, &buffer[0], 1500);

// resize the buffer if valid
if (iRead > 0)
  buffer.resize(iRead); // this logically trims the buffer so that the iterators begin/end are correct.

return buffer;

然后在调用函数中，使用vector<char> ，如果需要一个字符串，则从中构造一个： std::string foo(vect.begin(), vect.end()); 等等

Answer 4

设置空终止符“ bufptr [（int）iIn

bufptr [iMax] => bufptr [1024] =>您的分配超出了一个字节，因为数组从0开始。

在这种情况下也是int“ int iMax = buffer + buffer_size-bufptr;” 可以重写为iMax = buffer_size。 它使代码的可读性降低。