C++ - 多个buffer合并成一个buffer的管理类

已于 2024-04-16 23:39:37 修改
阅读量579 收藏 6
点赞数 4
CC 4.0 BY-SA版权
文章标签： c++ buffer
于 2024-03-08 15:31:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LostSpeed/article/details/136562145
博客介绍了用C++实现的将多个buffer合并成一个buffer的管理类。客户端向服务端提交多buffer信息较麻烦，该管理类可将多个buffer封装成一个，只需提交一次。还能从大buffer中提取小buffer信息。此外，提到对提交内容加密的两种方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

C++ - 多个buffer合并成一个buffer的管理类

概述

客户端要向服务端提交包含在多个buffer中的信息, 如果提交多个buffer(文件), 挺麻烦的.
如果将这些buffer(文件), 压缩成一个文件, 处理起来也不是很方便.

尝试将多个buffer封装到一个buffer中, 最终将封装好的buffer(写成文件也行)给服务端, 只需要提交一次.
封装了一个管理类, 可以向管理类push多个buffer, 最后调用接口, 得到一个完整的大buffer(包含所有压入的小buffer).
对提取的大buffer, 使用者的程序, 再调用分析接口, 可以取得调用者压入的多个小buffer的具体信息.

笔记

运行效果

	header info :
	name = myapp_cfg
	buffer total len = 265
	buffer block cnt = 3
	----------------
	dataBlock[0] = hd_info, ver = 0X1000100, datalen = 40, data below
	0000 - 31 2e 20 77 65 20 67 65-74 20 73 6f 6d 65 20 68   1. we get some h
	0010 - 61 72 64 77 61 72 65 20-69 6e 66 6f 20 66 72 6f   ardware info fro
	0020 - 6d 20 63 6c 69 65 6e 74-                          m client
	----------------
	dataBlock[1] = soft_info, ver = 0X1000100, datalen = 40, data below
	0000 - 32 2e 20 77 65 20 67 65-74 20 73 6f 6d 65 20 73   2. we get some s
	0010 - 6f 66 74 77 61 72 65 20-69 6e 66 6f 20 66 72 6f   oftware info fro
	0020 - 6d 20 63 6c 69 65 6e 74-                          m client
	----------------
	dataBlock[2] = stuff_info, ver = 0X1010001, datalen = 37, data below
	0000 - 32 2e 20 77 65 20 67 65-74 20 73 6f 6d 65 20 73   2. we get some s
	0010 - 74 75 66 66 20 69 6e 66-6f 20 66 72 6f 6d 20 63   tuff info from c
	0020 - 6c 69 65 6e 74                                    lient
	free map, g_mem_hook_map.size() = 0

测试工程实现

main.cpp

/*!
* \file main.cpp
*/

#include "my_openSSL_lib.h"
#include <openssl/crypto.h>
#include <openssl/bio.h>

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

#include "CMemHookRec.h"

#include "CMyDataContainerBase.h"

bool make_DataBuffer(uint8_t*& pBuf, int& lenBuf);
bool use_DataBuffer(uint8_t*& pBuf, int& lenBuf);

void my_openssl_app();

int main(int argc, char** argv)
{
	setvbuf(stdout, NULL, _IONBF, 0); // 清掉stdout缓存, 防止调用printf时阻塞
	mem_hook();

	my_openssl_app();

	mem_unhook();

	/*! run result
	header info :
	name = myapp_cfg
	buffer total len = 265
	buffer block cnt = 3
	----------------
	dataBlock[0] = hd_info, ver = 0X1000100, datalen = 40, data below
	0000 - 31 2e 20 77 65 20 67 65-74 20 73 6f 6d 65 20 68   1. we get some h
	0010 - 61 72 64 77 61 72 65 20-69 6e 66 6f 20 66 72 6f   ardware info fro
	0020 - 6d 20 63 6c 69 65 6e 74-                          m client
	----------------
	dataBlock[1] = soft_info, ver = 0X1000100, datalen = 40, data below
	0000 - 32 2e 20 77 65 20 67 65-74 20 73 6f 6d 65 20 73   2. we get some s
	0010 - 6f 66 74 77 61 72 65 20-69 6e 66 6f 20 66 72 6f   oftware info fro
	0020 - 6d 20 63 6c 69 65 6e 74-                          m client
	----------------
	dataBlock[2] = stuff_info, ver = 0X1010001, datalen = 37, data below
	0000 - 32 2e 20 77 65 20 67 65-74 20 73 6f 6d 65 20 73   2. we get some s
	0010 - 74 75 66 66 20 69 6e 66-6f 20 66 72 6f 6d 20 63   tuff info from c
	0020 - 6c 69 65 6e 74                                    lient
	free map, g_mem_hook_map.size() = 0
	*/

	return 0;
}

void my_openssl_app()
{
	uint8_t* pBuf = NULL;
	int lenBuf = 0;

	make_DataBuffer(pBuf, lenBuf);
	use_DataBuffer(pBuf, lenBuf);

	if (NULL != pBuf)
	{
		delete[] pBuf;
		pBuf = NULL;
	}
}

bool make_DataBuffer(uint8_t*& pBuf, int& lenBuf)
{
	CMyDataContainerBase* pDataContainer = NULL;
	bool b_rc = false;
	char szBuf[1024];

	do {
		pDataContainer = new CMyDataContainerBase();
		if (NULL == pDataContainer)
		{
			break;
		}

		// my app cfg 1.0.0.1
		pDataContainer->SetHeader("myapp_cfg", 0x01000001);

		// add data block - hdinfo 1.0.1.0
		strcpy(szBuf, "1. we get some hardware info from client");
		pDataContainer->addDataBuffer("hd_info", 0x01000100, (uint8_t*)szBuf, strlen(szBuf));

		// add data block - soft info 1.0.1.0
		strcpy(szBuf, "2. we get some software info from client");
		pDataContainer->addDataBuffer("soft_info", 0x01000100, (uint8_t*)szBuf, strlen(szBuf));

		// add data block - stuff info 1.1.0.1
		strcpy(szBuf, "2. we get some stuff info from client");
		pDataContainer->addDataBuffer("stuff_info", 0x01010001, (uint8_t*)szBuf, strlen(szBuf));

		if (!pDataContainer->GetTotalBuffer(pBuf, lenBuf))
		{
			assert(false);
			break;
		}

		b_rc = true;
	} while (false);

	if (NULL != pDataContainer)
	{
		delete pDataContainer;
		pDataContainer = NULL;
	}

	return b_rc;
}

bool use_DataBuffer(uint8_t*& pBuf, int& lenBuf)
{
	bool b_rc = false;
	CMyDataContainerBase* pDataContainer = NULL;
	TAG_DATA_CONTAINER_HEADER* pheader = NULL;
	TAG_DATA_BUFFER* pDataBuffer = NULL;
	int i = 0;

	do {
		pDataContainer = new CMyDataContainerBase();
		if (NULL == pDataContainer)
		{
			assert(false);
			break;
		}

		if (!pDataContainer->loadBuffer(pBuf, lenBuf))
		{
			assert(false);
			break;
		}

		if (!pDataContainer->getHeader(pheader))
		{
			assert(false);
			break;
		}

		printf("header info :\n");
		printf("name = %s\n", (char*)pheader->name_8d3);
		printf("buffer total len = %d\n", pheader->totoal_len);
		printf("buffer block cnt = %d\n", pheader->databuffer_cnt);
		
		for (i = 0; i < pheader->databuffer_cnt; i++)
		{
			printf("----------------\n");
			if (!pDataContainer->getDataBuffer(i, pDataBuffer))
			{
				assert(false);
				goto label_err;
			}

			printf("dataBlock[%d] = %s, ver = 0X%X, datalen = %d, data below\n", i, (char*)pDataBuffer->name_8d3, pDataBuffer->ver, pDataBuffer->len_data);
			BIO_dump_fp(stdout, pDataBuffer->pdata, pDataBuffer->len_data);
		}

		b_rc = true;
	} while (false);

label_err:
	return b_rc;
}

CMyDataContainerBase.h

//! \file CMyDataContainerBase.h
//! \note 将多个指针存到buffer中, 接收者将多个指针从数据块中提取出来用

#include <cstdint>
#include <list>
#ifndef __CMYDATACONTAINERBASE_H__
#define __CMYDATACONTAINERBASE_H__

// 数据容器形成buffer(文件)之后的格式
// TAG_DATA_CONTAINER_HEADER[1]
// TAG_DATA_BUFFER[n]
// data_block[n]

typedef struct _tag_data_container_header
{
	uint8_t name_8d3[13];
	int totoal_len; // 数据容器文件的大小, 从文件开头算起, 到文件结尾
	int databuffer_cnt;
	uint8_t hash[32];
}TAG_DATA_CONTAINER_HEADER;

typedef struct _tag_data_buffer
{
	uint8_t name_32[33];
	uint8_t* pdata;
	int posOnTotalMem; // 在数据文件中的位置, 从数据文件开头算起
	int len_data;

	_tag_data_buffer()
	{
		memset(name_32, 0, sizeof(name_32));
		pdata = NULL;
		posOnTotalMem = 0;
		len_data = 0;
	}
}TAG_DATA_BUFFER;

class CMyDataContainerBase
{
public:
	CMyDataContainerBase();
	virtual ~CMyDataContainerBase();

	void clear();

	// 组装者用的接口
	void SetHeader(const char* pszName8d3);
	void addDataBuffer(const char* pszName8d3, uint8_t* pdata, int len_data); // pdata内容会复制到类内部, 和外部指针无关

	// 如果要对数据做附加处理, 可以继承此类, 先调用父类接口实现, 再对数据做其他处理(e.g. encrypt/encode)

	// 只是更新了pBuf中的header中的hash值!!!
	bool update_hash(uint8_t*& pBuf, int& lenBuf); // 此时，应是数据都加完了，调用了GetTotalBuffer(), 然后送进update()来更新header中的hash

	virtual bool GetTotalBuffer(uint8_t*& pBuf, int& lenBuf); // 得到的pBuf需要调用者自己释放

	// 接受者用的接口
	// 如果要对数据做附加处理, 可以继承此类, 先对数据做其他处理(e.g. decrypt/decode), 再调用父类接口
	virtual bool loadBuffer(uint8_t* pBuf, int lenBuf);

	bool getHeader(TAG_DATA_CONTAINER_HEADER*& header);
	bool getDataBuffer(int index, TAG_DATA_BUFFER*& dataBuf);
	
private:
	TAG_DATA_CONTAINER_HEADER m_header;
	std::list<TAG_DATA_BUFFER*> m_list;
};

#endif // #ifndef __CMYDATACONTAINERBASE_H__

CMyDataContainerBase.cpp

//! \file CMyDataContainerBase.cpp

#include "pch.h"

#include "MemOpt/CMyDataContainerBase.h"
#include <cassert>
#include "openssl/evp.h"

#include "memOpt/my_debug_new_define.h"
#include <cipher/cipher_sha3_512.h>

CMyDataContainerBase::CMyDataContainerBase()
{
	clear();
}

CMyDataContainerBase::~CMyDataContainerBase()
{
	clear();
}

void CMyDataContainerBase::clear()
{
	std::list<TAG_DATA_BUFFER*>::iterator it;
	TAG_DATA_BUFFER* dataBuffer = NULL;

	memset(&m_header, 0, sizeof(m_header));

	for (it = m_list.begin(); it != m_list.end(); it++)
	{
		dataBuffer = *it;
		if (NULL != dataBuffer)
		{
			if (NULL != dataBuffer->pdata)
			{
				delete[] dataBuffer->pdata;
				dataBuffer->pdata = NULL;
			}

			// 这是我今天上午修正的内存泄漏
			delete dataBuffer;
			dataBuffer = NULL;
		}
	}

	m_list.clear();
}

void  CMyDataContainerBase::SetHeader(const char* pszName8d3)
{
	do {
		if ((NULL == pszName8d3) || (strlen(pszName8d3) > sizeof(m_header.name_8d3)))
		{
			assert(false);
			break;
		}

		strcpy((char*)m_header.name_8d3, pszName8d3);
	} while (false);
}

void CMyDataContainerBase::addDataBuffer(const char* pszName8d3, uint8_t* pdata, int len_data)
{
	TAG_DATA_BUFFER* pDataBuffer = NULL;
	int len = 0;
	do {
		if (NULL != pszName8d3)
		{
			len = (int)strlen(pszName8d3);
		}

		if ((NULL == pszName8d3) || (strlen(pszName8d3) >= sizeof(TAG_DATA_BUFFER::name_32)))
		{
			assert(false);
			break;
		}

		if ((NULL == pdata) || (len_data <= 0))
		{
			assert(false);
			break;
		}

		pDataBuffer = new TAG_DATA_BUFFER;
		if (NULL == pDataBuffer)
		{
			assert(false);
			break;
		}

		memset(pDataBuffer, 0, sizeof(TAG_DATA_BUFFER));
		strcpy((char*)pDataBuffer->name_32, pszName8d3);
		pDataBuffer->posOnTotalMem = 0;
		pDataBuffer->len_data = len_data;
		pDataBuffer->pdata = new uint8_t[pDataBuffer->len_data];
		if (NULL == pDataBuffer->pdata)
		{
			assert(false);
			break;
		}

		memcpy(pDataBuffer->pdata, pdata, pDataBuffer->len_data);

		m_list.push_back(pDataBuffer);
	} while (false);
}

bool CMyDataContainerBase::update_hash(uint8_t*& pBuf, int& lenBuf)
{
	bool b_rc = false;
	bool b = false;
	TAG_DATA_CONTAINER_HEADER* pHeader = NULL;
	CCipherSha3_256 hash;

	do {
		if ((NULL == pBuf) || (lenBuf <= 0))
		{
			break;
		}

		pHeader = (TAG_DATA_CONTAINER_HEADER*)(pBuf + 0);
		memset(pHeader->hash, 0, sizeof(pHeader->hash));

		b = hash.begin();
		assert(true == b);

		hash.update(pBuf, lenBuf);
		assert(true == b);

		hash.end();
		assert(true == b);

		assert(hash.get_md_len() == sizeof(pHeader->hash));
		memcpy(pHeader->hash, hash.get_md(), hash.get_md_len());

		b_rc = true;
	} while (false);

	return b_rc;
}

bool CMyDataContainerBase::GetTotalBuffer(uint8_t*& pBuf, int& lenBuf)
{
	bool b_rc = false;
	pBuf = NULL;
	lenBuf = 0;

	int szList = 0;
	std::list<TAG_DATA_BUFFER*>::iterator it;
	TAG_DATA_CONTAINER_HEADER* pHeader = NULL;
	TAG_DATA_BUFFER* pDataBuffer = NULL;
	TAG_DATA_BUFFER* pDataBufferMem = NULL;
	uint8_t* pDataBufferMemData = NULL; // pBuf用的
	int i = 0;
	int lenDataTotalNow = 0;

	do {
		// 数据容器形成buffer(文件)之后的格式
		// TAG_DATA_CONTAINER_HEADER[1]
		// TAG_DATA_BUFFER[n]
		// data_block[n]
		
		szList = (int)m_list.size();
		lenBuf = sizeof(TAG_DATA_CONTAINER_HEADER) + szList * sizeof(TAG_DATA_BUFFER);

		lenDataTotalNow = 0;
		for (i = 0, it = m_list.begin(); it != m_list.end(); it++, i++)
		{
			pDataBuffer = *it;
			if (NULL == pDataBuffer)
			{
				assert(false);
				goto label_err;
			}

			lenBuf += pDataBuffer->len_data;

			pDataBuffer->posOnTotalMem = (int)(sizeof(TAG_DATA_CONTAINER_HEADER) + szList * sizeof(TAG_DATA_BUFFER) + lenDataTotalNow);
			lenDataTotalNow += pDataBuffer->len_data;
		}

		pBuf = (uint8_t*)OPENSSL_malloc(lenBuf);
		if (NULL == pBuf)
		{
			assert(false);
			break;
		}

		memset(pBuf, 0, lenBuf);

		// 填充header;
		m_header.databuffer_cnt = szList;
		m_header.totoal_len = lenBuf;
		memset(m_header.hash, 0, sizeof(m_header.hash));

		// copy header
		pHeader = (TAG_DATA_CONTAINER_HEADER*)(pBuf + 0);
		memcpy(pHeader, &m_header, sizeof(m_header));

		// 依次填充DataBuffer
		for (i= 0, it = m_list.begin(); it != m_list.end(); it++, i++)
		{
			pDataBuffer = *it;

			pDataBufferMem = (TAG_DATA_BUFFER*)(pBuf + sizeof(TAG_DATA_CONTAINER_HEADER) + i * sizeof(TAG_DATA_BUFFER));
			memcpy(pDataBufferMem, pDataBuffer, sizeof(TAG_DATA_BUFFER));
			pDataBufferMem->pdata = NULL; // 放入buffer之后，pdata就没用了，而且会影响算hash.

			pDataBufferMemData = (pBuf + pDataBuffer->posOnTotalMem);
			memcpy(pDataBufferMemData, pDataBuffer->pdata, pDataBuffer->len_data);
		}

		b_rc = true;
	} while (false);

label_err:

	return b_rc;
}

bool CMyDataContainerBase::loadBuffer(uint8_t* pBuf, int lenBuf)
{
	bool b_rc = false;
	TAG_DATA_CONTAINER_HEADER* pHeader = NULL;
	TAG_DATA_BUFFER* pDataBuf = NULL;
	int iTotalLenNow = 0;
	int i = 0;

	do {
		if ((NULL == pBuf) || (lenBuf <= 0))
		{
			break;
		}

		clear();

		// 数据容器形成buffer(文件)之后的格式
		// TAG_DATA_CONTAINER_HEADER[1]
		// TAG_DATA_BUFFER[n]
		// data_block[n]

		iTotalLenNow += sizeof(TAG_DATA_CONTAINER_HEADER);
		if (iTotalLenNow > lenBuf)
		{
			break;
		}

		pHeader = (TAG_DATA_CONTAINER_HEADER*)pBuf;
		iTotalLenNow += (pHeader->databuffer_cnt * sizeof(TAG_DATA_BUFFER));
		if (iTotalLenNow > lenBuf)
		{
			break;
		}

		for (i = 0; i < pHeader->databuffer_cnt; i++)
		{
			pDataBuf = (TAG_DATA_BUFFER*)(pBuf + sizeof(TAG_DATA_CONTAINER_HEADER) + sizeof(TAG_DATA_BUFFER));
			if ((pDataBuf->posOnTotalMem + pDataBuf->len_data) > lenBuf)
			{
				goto label_err;
			}
		}

		// 到此, 数据格式基本正确
		// 将数据载入 m_header, m_list
		memcpy(&m_header, (pBuf + 0), sizeof(TAG_DATA_CONTAINER_HEADER));
		for (i = 0; i < pHeader->databuffer_cnt; i++)
		{
			pDataBuf = new TAG_DATA_BUFFER;
			if (NULL == pDataBuf)
			{
				assert(false);
				goto label_err;
			}

			memcpy(pDataBuf, (pBuf + sizeof(TAG_DATA_CONTAINER_HEADER) + i * sizeof(TAG_DATA_BUFFER)), sizeof(TAG_DATA_BUFFER));
			pDataBuf->pdata = new uint8_t[pDataBuf->len_data];
			if (NULL == pDataBuf->pdata)
			{
				assert(false);
				goto label_err;
			}

			memcpy(pDataBuf->pdata, pBuf + pDataBuf->posOnTotalMem, pDataBuf->len_data);
			m_list.push_back(pDataBuf);
		}

		b_rc = true;
	} while (false);

label_err:
	return b_rc;
}

bool CMyDataContainerBase::getHeader(TAG_DATA_CONTAINER_HEADER*& header)
{
	header = &m_header;
	return true;
}

bool CMyDataContainerBase::getDataBuffer(int index, TAG_DATA_BUFFER*& dataBuf)
{
	bool b_rc = false;
	std::list<TAG_DATA_BUFFER*>::iterator it;
	int i = 0;
	TAG_DATA_BUFFER* pDataBuffer = NULL;

	do {
		if (index >= this->m_header.databuffer_cnt)
		{
			break;
		}

		for (i = 0, it = m_list.begin(); it != m_list.end(); it++, i++)
		{
			if (i != index)
			{
				continue;
			}

			pDataBuffer = *it;
			if (NULL == pDataBuffer)
			{
				assert(false);
				goto label_err;
			}

			dataBuf = pDataBuffer;
			b_rc = true;
			break;
		}
	} while (false);
	
label_err:
	return b_rc;
}

备注

如果不想用户直接能分析提交的内容(因为buffer的内容有可能包含ascii字符, 人眼可以分辨), 现在能想到的方法有2种:

  • 在执行GetTotalBuffer()后, 得到总的buffer, 对buffer做编解码/加解密处理
  • 直接从CMyDataContainerBase继承一个子类, 重载GetTatalBuffer()/loadBuffer(), 对提交/载入的数据在子类中直接处理.

END

LostSpeed
关注
Node.js Buffer.concat 方法详解：合并多个 Buffer 实例
红衣大叔
08-05 929
在Node.js中，是一个静态方法，用于将多个Buffer实例合并成一个新的Buffer实例。这个方法在处理网络流、文件操作等需要组合多个二进制数据片段的场景中非常有用。下面详细展开讲解方法。
c++ 实现高效缓存（链式buffer）
The Coding World
12-06 3658
如果我们从网络端接收的数据是不定长度的，不能提前分配好网络缓存大小，则可以选择使用链式缓存的实现方式。链式缓存主要是分配固定大小的缓存链保存数据，一个管理器去管理这些缓存链。 链式缓存示例： //一种链式缓冲 //ringbuffer是固定长度，不能够扩展，链式buffer可以任意扩充 /** * buffer * *first--chain buffer [1024] * ...
c# Buffer.BlockCopy 合并 byte 数组
weixin_30326745的博客
06-24 555
今天遇到点问题需要合并 多个 byte[] 参见 ： http://q.cnblogs.com/q/30534/ 今天复习了 所有数组的基类是 Array 转载于:https://www.cnblogs.com/bingguang/p/4597970.html...
小心buffer的拼接问题 --转
weixin_33874713的博客
11-11 127
最近遇见一个从前没有遇见的陷阱，就是data里的chunk拼接。 由于本人身为前端工程师，对buffer的概念实在是认识不足。这次的场景是我要通过http.get去抓取远端的网页文件，很不小心的是对方的文件编码 是gbk（估计是老年代Java环境下的解决方案），而我本地的代码是utf8的编码，最终我需要将两部分代码合并之后输出到客户端，所以我需要将接受到 的部分进行转码，转码则需要通...
有关stdint中unit部分操作：合并，加法
nanshenjiang的博客
02-06 322
#include <stdio.h> #include <stdint.h> int main(int argc, char* argv[]) { //16位转两个8位 uint8_t a, b, c, d; uint16_t f = 0x1234; c = (f >> 8) & 0x00ff; d = f & 0x00ff; printf("a: %#x, b: %#xn", a,b); //3.
C++将多个文件压缩成一个tar文件
05-10
以下是一个简单的示例代码，可以将多个文件打包成一个tar文件： ```c++ #include #include #include #include #include #include int main(int argc, char** argv) { // 检查参数是否正确 if (argc ) { ...
写出完整libusb 异步传输例程，使用多线程读写操作，使用c++实现，封装成一个类
10-10
在C++中，我们可以创建一个类来封装libusb的异步传输功能，采用多线程读写操作。以下是一个基本的示例，展示了一个名为`UsbAsyncTransfer`的类，包含了设备打开、关闭以及异步读写的方法： ```cpp #include #...
一个OPenGLFramebuffer绑定多个帧附件 ，多个帧缓冲拼接成一张图片 给出详细代码 C++
最新发布
12-04
在OpenGL中，你可以使用Framebuffer Objects (FBOs) 和 Framebuffer Attachments 来合并多个帧缓冲的内容。通常，这涉及到创建多个FBO，每个FBO都有一个颜色附件，然后将它们链接在一起。以下是一个基本的例子，展示...
基于多反应堆的高并发服务器【C/C++/Reactor】（中）Buffer的创建和销毁、扩容、写入数据
呵呵哒!的博客
01-04 868
函数时，需要考虑如何处理内存的写入和接收数据的情况。在写数据之前，可能需要进行内存扩容以确保有足够的空间。写数据时，需要从上次写入的。在实现内存扩容函数时，需要考虑如何处理内存的写入和接收数据的情况。写数据之前可能需进行内存扩容，并从上次写入的。完成写入后，需要再次更新。内核中减少了多次系统调用的开销。位置开始，完成写入后再次更新。（2）然后把这块内存的数据。一次接收多个缓冲区中的数据。这块内存的大小，将值赋给。移动内存实现合并内存。到前面去，这就实现了。
CMU 15-445 Lab1 - Buffer Pool Manager
我想孤独终老，不想再入爱河。
11-10 1827
Lab1 - Buffer Pool Manager 实验指导书 构建一个新的面向磁盘的存储管理器，这样的存储管理器假定数据库的主要存储位置在磁盘上。 在存储管理器中实现缓冲池。缓冲池负责将 pag 从主存到磁盘来回移动。允许 DBMS 支持大于系统可用内存量的数据库。缓冲池的操作对系统中的其他部分是透明的。例如，系统使用其唯一标识符 ( page_id_t)向缓冲池请求页面，但它不知道该页面是否已经在内存中，或者系统是否必须从磁盘中检索它。 实现需要是线程安全的。多个线程将同时访问内
拼接缓冲区Buffer中的内容
weixin_43446193的博客
03-04 818
拼接缓冲区buf.concat 在实际开发中，有时会遇到这样的需求，输出两个成多个缓冲区中内容的组合。为了解决这样的需求，Node js中提供拼接缓冲区的函数，语法如下: buf.concat(list[，totalLength]); 上述语法执行后返回一个多个成员合并的新Buffer对象。其中，list 用于合并的Buffer对象数组列表，totalLength用于指定合并后Buffer对象的...
C++ 对一个字节的拆分与合并
Start_of_Our的博客
12-11 1971
1：C++ 将一个字节拆分成 8位 int main(int argc, char *argv[]) { uint8_t value = 106; //二进制数 0110 1010 for(int i = 0; i < 8; i++) { uint8_t twoPow = pow(2, i); int S_value = (value & twoPow) >> i; qDebug() <<
浅谈C++中的buffer
爱学习的影峰的博客
02-19 1万+
一、C++中buffer是什么?1、buffer就是缓冲区的意思。当数据从其他地方接受过来在处理前，先保存至缓冲区，然后进行发送，主要用于处理能力或效率不相同的两个设备之间进行协调。2、buffer一般用来定义数组，因为它本身的意思就是“缓冲区”，在C语言里，数组就是个缓冲区，所以用常常用它。用它没有别的意思，就是方便记，可以用shuzu mydata甚至自己名字的拼音都行，主要是用它别人也很容易...
buffer正确的拼接方式
weixin_30691871的博客
10-19 344
var chunks = []; var size = 0; res.on('data',function(chunk){ chunks.push(chunk); size+= chunk.length; }); res.on('end',function(){ var buf = Buffer.concat(chunks,size); ...
StringBuffer和String拼接功能
Shaun_Guo的博客
03-13 5351
package gxx;//用StringBuffer做拼接不会浪费太多资源//StringBuffer 的添加功能：//public StringBuffer append(String str):可以把任意类型的数据添加到字符串缓冲区里面，并返回字符串缓冲区本身//形参问题：基本类型：形参的改变不影响实际参数//引用类型：形参的改变直接影响实际参数//注意：String作为参数传递，效果和基本...
C++之string的拼接
This is bill的专属博客
04-04 2万+
字符拼接可以采用的方法：1、多个字串拼接时用+操作符1）代码：如果不加红色部分的代码，则需要采用_sntprintf代替sntprintf。[cpp] view plain copy#include   #include   #define snprintf _snprintf  #endif  using namespace std;    string intToString(int v)
C#合并两个字节数组的方法_艾孜尔江撰
热门推荐
艾孜尔江的博客
02-11 4万+
public static byte[] addBytes(byte[] data1, byte[] data2, int validLen) { if (validLen <= 0) { throw new Exception("Data2 cannot be null!"); } if (...
一个C++实用的buffer类
Y_jay的博客
04-02 3916
/* * @brief Safely Buffer */ class Buffer { public: Buffer() : _data(nullptr), _size(0) { } Buffer(const byte* data, size_t size) : _data(nullptr), _size(0) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值