小编jds*_*oso的帖子

我正在尝试实现一个结构来保存二进制数据.像这样:

struct Buffer {
    int size_;
    int capacity = 1000000;
    int beg_index, end_index;
    char data_[1000000];
} buffer_audio[3];

以及在缓冲区中写入二进制数据的函数:

int writing_bufer(Buffer buffers, const char *data, int nbytes) {
    if (nbytes == 0) return 0;

    int capacity = buffers.capacity;
    int bytes_to_write = std::min(nbytes, capacity - buffers.size_);

    if (bytes_to_write <= capacity - buffers.end_index)
    {

        memcpy(buffers.data_ + buffers.end_index, data, bytes_to_write);
        buffers.end_index += bytes_to_write;
        if (buffers.end_index == capacity) buffers.end_index = 0;
    }
    else { return 0; }  

    buffers.size_ += bytes_to_write;
    return bytes_to_write;
}

但问题是..每次运行此例程时beg_index …

我使用一组结构来存储来自不同客户端的不同二进制数据.在我调试的时候,我可以成功进行一些迭代(在memcpy中).但在某些时候调试崩溃与"未处理的异常".

struct Buffer {
    int size_ = 0;
    int capacity_total = 200000;
    int beg_index = 0
    int end_index = 0;
    char data_[200000];
} buffer_audio[3];

int writing_bufer(Buffer& buffers, const char *data, int nbytes) {
    if (nbytes == 0) return 0;

    int capacity = buffers.capacity_total;

    if (nbytes <= capacity - buffers.end_index)
    {
        memcpy(buffers.data_ + buffers.end_index, data, nbytes); //crashes here
        buffers.end_index += nbytes;
        if (buffers.end_index == capacity) printf("full");
    }
    else { 
        return 0; }

    return buffers.end_index;
}

缓冲区永远不会满或接近.完整的例程:

void buffering(const FunctionCallbackInfo<v8::Value>& args) { …

我试图实现循环缓冲区.所以现在我正在测试一些代码.

raw_buffer.h

#include <algorithm> // for std::min

#ifndef RAWBUFFER_H
#define RAWBUFFER_H

class CircularBuffer
{
public:
    CircularBuffer(size_t capacity);
    ~CircularBuffer();

    size_t size() const { return size_; }
    size_t capacity() const { return capacity_; }
    // Return number of bytes written.
    size_t write(const char *data, size_t bytes);
    // Return number of bytes read.
    size_t read(char *data, size_t bytes);

private:
    size_t beg_index_, end_index_, size_, capacity_;
    char *data_;
};

extern CircularBuffer MyCircularBuffer;

#endif

main_raw.cpp

#include "raw_buffer.h"
#include <iostream>
#include <string>   

using namespace std;

    int main() …

考虑这个" 伪代码 "序列:

variable x

malloc(x);
free(x);
malloc(x);
free(x)
//..so on

这样做malloc,free顺序会导致内存泄漏吗？realloc是否需要使用？