c - 使用 Memcpy 将一些 Char* 附加到包含 Char* 的缓冲区

Question

我正在编写一个方法来将一些数据附加到缓冲区。

缓冲区看起来像:

Buffer *new_buffer(size_t reserved) {
    Buffer* buffer = malloc(sizeof(Buffer));
    buffer->data   = (char*)calloc(reserved, sizeof(char));
    buffer->length = reserved;
    return buffer;
}

我想向缓冲区追加数据，我写的方法如下:

void append_buffer(Buffer *buffer, char *data, size_t length) {
    if( buffer->length <= length ) {
        buffer->length = buffer->length + length;
        buffer->data   = realloc( buffer->data, buffer->length * 2 );
    }
    memcpy( &buffer->data[ strlen( buffer->data ) - 1 ], data, length );

}

请注意，大小参数只是要附加的数组的大小。

即

append_buffer(buffer, data, len_data);

我相信我的 memcpy 有错误；

思路是使用memcpy将缓冲区最后一个字符的数据放入内存；这样我们就可以避免终止字符。

运行它不会附加任何数据，我不太确定为什么!

Answer 1

当在 C 中使用包含任意二进制数据的缓冲区时，您需要存储两个长度字段:分配的缓冲区容量和当前存储在缓冲区中的数据量。

(与 C#/.NET 和 Java 相比，这就像 List<T>(Java 中的 ArrayList)同时具有内部 T[].Length 和单独的 Count 值)。

我重写了您的代码以展示我将如何做到这一点。请注意:

• Buffer struct 存储 capacity和length .
• 代码使用assert()验证参数并验证分配是否成功。这仅用于演示目的，因为 assert如果 NDEBUG 则从程序中删除是安全的，而内存分配应该始终被验证。
• 我将追加逻辑 ( append_buffer ) 与重新分配缓冲区的逻辑 ( expand_buffer ) 分开。

像这样:

#undef NDEBUG // So `assert` is always compiled.

struct Buffer {
    char*  data;
    size_t capacity; // Size of the actual allocated space
    size_t length;   // Amount of space currently used
};

struct Buffer* new_buffer( size_t initialCapacity ) {
    struct Buffer* info = malloc( sizeof(Buffer) ); // Allocate space for the metadata
    assert( info ); // Always ensure allocation succeeded!
    info->data = calloc( initialCapacity, sizeof(char) );
    assert( info->data );
    info->capacity = initialCapacity;
    info->length   = 0;
    return info;
}

void append_buffer( struct Buffer* buffer, char* data, size_t dataLength ) {
    assert( buffer ); // Parameter argument validation
    assert( data );
    if( dataLength == 0 ) return;

    size_t remainingCapacity = buffer->capacity - buffer->length;
    if( remainingCapacity < dataLength ) {
        size_t desiredCapacity = buffer->capacity + dataLength; // You might want to add a growth factor here
        expand_buffer( buffer, desiredCapacity );
    }

    char* start = buffer->data + buffer->length;
    memcpy( start, data, dataLength );
    buffer->length += dataLength;
}

void expand_buffer( struct Buffer* buffer, size_t desiredCapacity ) {
    assert( buffer );
    assert( buffer->data );
    char* newData = realloc( buffer->data, desiredCapacity );
    assert( newData );
    buffer->data     = newData;
    buffer->capacity = desiredCapacity;
    // buffer->length remains unchanged
}

void destroy_buffer( struct Buffer* buffer ) {
    assert( buffer );

    if( buffer-> data ) {
        free( buffer->data );
        buffer->data = NULL;
    }

    free( buffer );
}