ipc::buffer

数据缓冲区对象，用于IPC通讯中的数据传输。自动管理内存生命周期，提供了安全高效的数据封装。

class IPC_EXPORT buffer {
public:
    using destructor_t = void (*)(void*, std::size_t);

    buffer();
    buffer(void* p, std::size_t s, destructor_t d);
    buffer(void* p, std::size_t s, destructor_t d, void* mem_to_free);
    buffer(void* p, std::size_t s);

    template <std::size_t N>
    explicit buffer(byte_t (& data)[N]);
    explicit buffer(char & c);

    buffer(buffer&& rhs);
    ~buffer();

    void swap(buffer& rhs);
    buffer& operator=(buffer rhs);

    bool empty() const noexcept;
    void *       data()       noexcept;
    void const * data() const noexcept;

    template <typename T>
    T get() const;

    std::size_t size() const noexcept;

    std::tuple<void*, std::size_t> to_tuple();
    std::tuple<void const *, std::size_t> to_tuple() const;
    std::vector<byte_t> to_vector() const;

    friend bool operator==(buffer const & b1, buffer const & b2);
    friend bool operator!=(buffer const & b1, buffer const & b2);
};

成员	说明
destructor_t	析构函数类型定义
buffer	构造函数
~buffer	析构函数
swap	交换两个buffer的内容
operator=	移动赋值操作
empty	判断buffer是否为空
data	获取数据指针
get	获取指定类型的数据指针
size	获取数据大小
to_tuple	转换为tuple
to_vector	转换为vector
operator==, operator!=	比较操作符

destructor_t

using destructor_t = void (*)(void*, std::size_t);

析构函数类型定义。当buffer对象销毁时，会调用此函数释放内存。

参数	说明
void*	指向需要释放的内存地址
std::size_t	内存大小

buffer

/*A*/ buffer();
/*B*/ buffer(void* p, std::size_t s, destructor_t d);
/*C*/ buffer(void* p, std::size_t s, destructor_t d, void* mem_to_free);
/*D*/ buffer(void* p, std::size_t s);
/*E*/ template <std::size_t N>
      explicit buffer(byte_t (& data)[N]);
/*F*/ explicit buffer(char & c);
/*G*/ buffer(buffer&& rhs);

构造函数。

• A. 默认构造函数，创建一个空buffer
• B. 带析构函数的构造函数，指定数据指针、大小和析构函数
• C. 带独立释放地址的构造函数，用于数据指针是某个大块内存的一部分时
• D. 简单构造函数，指定数据指针和大小（不提供析构函数）
• E. 从字节数组构造
• F. 从单个字符构造（注意：需要非const引用）
• G. 移动构造函数

参数	说明
p	void*，数据指针
s	std::size_t，数据大小
d	destructor_t，析构函数，当buffer销毁时调用
mem_to_free	void*，实际需要释放的内存地址（当p是某个大块内存的一部分时使用）
data	byte_t (&)[N]，字节数组引用
c	char &，字符引用（非const）
rhs	buffer&&，另一个buffer对象的右值引用

使用示例

// 默认构造
ipc::buffer buf1;

// 从现有内存构造（不拥有所有权）
char data[100];
ipc::buffer buf2(data, sizeof(data));

// 从动态分配的内存构造（拥有所有权）
char* ptr = new char[100];
ipc::buffer buf3(ptr, 100, [](void* p, std::size_t) { delete[] (char*)p; });

// 从偏移内存构造（指定独立的释放地址）
char* block = new char[100];
char* offset_data = block + 25;
ipc::buffer buf4(offset_data, 50, [](void* p, std::size_t) { 
    delete[] (char*)p; 
}, block);  // 释放block而不是offset_data

// 从字节数组构造
byte_t arr[64];
ipc::buffer buf5(arr);

// 移动构造
ipc::buffer buf6(std::move(buf3));

~buffer

~buffer();

析构函数。销毁buffer对象，如果设置了析构函数，会自动调用它来释放内存。

swap

void swap(buffer& rhs);

交换两个buffer的内容。

参数	说明
rhs	buffer&，另一个buffer对象的引用

operator=

buffer& operator=(buffer rhs);

移动赋值操作。仅支持移动赋值，不支持拷贝赋值。

参数	说明
rhs	buffer，另一个buffer对象（copy-and-swap惯用法）

ipc::buffer buf1(ptr1, size1, destructor);
ipc::buffer buf2;
buf2 = std::move(buf1);  // 移动赋值

empty

bool empty() const noexcept;

判断buffer是否为空。

返回值	说明
true	buffer为空（size为0或data为nullptr）
false	buffer非空

data

/*A*/ void *       data()       noexcept;
/*B*/ void const * data() const noexcept;

获取buffer的数据指针。

• A. 非const版本，返回可修改的指针
• B. const版本，返回只读指针

返回值	说明
void* / void const *	指向buffer数据的指针

get

template <typename T>
T get() const;

获取指定类型的数据指针。这是一个模板方法，可以将内部指针转换为任意类型。

模板参数	说明
T	目标类型（通常是指针类型）

返回值	说明
T	转换后的数据指针

ipc::buffer buf = receive_data();
char* str = buf.get<char*>();
int* num = buf.get<int*>();

size

std::size_t size() const noexcept;

获取buffer的数据大小。

返回值	说明
std::size_t	数据大小（字节数）

to_tuple

/*A*/ std::tuple<void*, std::size_t> to_tuple();
/*B*/ std::tuple<void const *, std::size_t> to_tuple() const;

将buffer转换为tuple，包含数据指针和大小。

• A. 非const版本，返回可修改的指针
• B. const版本，返回只读指针

返回值	说明
std::tuple<void*, std::size_t>	包含数据指针和大小的tuple

ipc::buffer buf(data, 100);
auto [ptr, sz] = buf.to_tuple();  // C++17
// C++14:
auto tuple = buf.to_tuple();
void* ptr = std::get<0>(tuple);
std::size_t sz = std::get<1>(tuple);

to_vector

std::vector<byte_t> to_vector() const;

将buffer的数据复制到vector中。

返回值	说明
std::vector<byte_t>	包含buffer数据副本的vector

ipc::buffer buf(data, 100);
std::vector<byte_t> vec = buf.to_vector();

比较操作符

friend bool operator==(buffer const & b1, buffer const & b2);
friend bool operator!=(buffer const & b1, buffer const & b2);

比较两个buffer是否相等。比较基于数据内容和大小。

参数	说明
b1, b2	buffer const &，要比较的两个buffer对象

返回值	说明
true / false	buffer相等或不相等

ipc::buffer buf1(data1, 100);
ipc::buffer buf2(data2, 100);
if (buf1 == buf2) {
    // 数据相同
}

使用场景

1. 接收IPC数据

ipc::route cc { "my-route", ipc::receiver };
ipc::buffer buf = cc.recv();
if (!buf.empty()) {
    char* str = buf.get<char*>();
    std::cout << "Received: " << str << std::endl;
}

2. 发送IPC数据

ipc::route cc { "my-route" };
std::string message = "Hello, IPC!";
cc.send(message);  // 自动转换为buffer

3. 自定义内存管理

// 使用自定义分配器
void* ptr = my_allocator.allocate(1024);
ipc::buffer buf(ptr, 1024, [](void* p, std::size_t sz) {
    my_allocator.deallocate(p, sz);
});

注意事项

• buffer是移动语义对象，不支持拷贝
• 从单个字符构造时，必须提供非const引用（避免意外修改常量）
• 使用mem_to_free参数时，确保它指向实际分配的内存起始地址
• buffer的析构函数会自动调用注册的destructor释放内存
• 空buffer（默认构造）不会调用析构函数