C++简单缓冲区类设计

已于 2024-09-27 17:16:02 修改
阅读量631 收藏 11
点赞数 7
分类专栏： #C++进阶 文章标签： c++ 开发语言
于 2024-09-27 17:11:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haokan123456789/article/details/142579275
版权

目录

1.引言

2.静态缓冲区

3.动态缓冲区

4.数据引用类

5.自动数据引用类

6.几种缓冲区的类关系图

7.注意事项

8.完整代码

1.引言

        在C++中，设计静态和动态缓冲区类时，需要考虑的主要差异在于内存管理的方式。静态缓冲区类通常使用固定大小的内存区域（即栈分配或静态分配），而动态缓冲区类则根据需要动态地分配和释放内存（即堆分配）。下面将分别展示这几种缓冲区类的基本设计思路。

        不管是静态缓冲区还是动态缓冲区，都有统一的访问接口，于是提取共用方法，组成基础类：

template <class T>
class CSimpleDataBufferBase : public CNoncopyable
{
public:
	typedef T  DataType;
	typedef T* DataTypePointer;
	typedef T& DataTypeReference;
	typedef const T ConstDataType;
	typedef const T* ConstDataTypePointer;
	typedef const T& ConstDataTypeReference;
	
public:
	CSimpleDataBufferBase() {}
	virtual ~CSimpleDataBufferBase() {}

public:
	virtual  DWORD GetSize() const = 0;
	virtual  DataTypePointer GetData() = 0;
	virtual  ConstDataTypePointer GetData() const = 0;
	virtual  DWORD GetMaxSize() const = 0;
	operator DataTypePointer() {  return GetData(); } 
	DataTypeReference operator*() { return *GetData(); }
	DataTypeReference operator[](int nIndex);
	virtual  BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize) = 0;
	virtual  void  Clear() = 0;
};

接口设计要点：

1）CSimpleDataBufferBase继承CNoncopyable，禁止构造拷贝和赋值拷贝。

2）访问缓冲区数据的接口，const和非const版本。

3）重载操作符*或[]访问缓冲区元素的数据

template <class T>
typename CSimpleDataBufferBase<T>::DataTypeReference CSimpleDataBufferBase<T>::operator[](int nIndex)
{
	if ( (nIndex >= 0) && (nIndex < (int)GetSize()))
	{
		DataTypePointer pData = GetData();
		return pData[nIndex];
	}
	else
	{
		throw std::out_of_range("invalid data<nIndex> position");
	}	
}

4）往缓冲区写数据接口，接收的是const T*和数据的长度。

5）获取缓冲区的上限。

5）清空缓冲区。

2.静态缓冲区

        静态缓冲区类通常包含一个固定大小的数组（或其他容器，但数组是最直接的例子），并提供一系列方法来操作这个数组。 静态缓冲区类CStaticSimpleDataBufferT实现代码如下：

//数据静态分配
template <class T>
class CStaticSimpleDataBufferT : public CSimpleDataBufferBase<T>
{
public:
	CStaticSimpleDataBufferT(DWORD dwMaxSize = MAX_STATIC_SIMPLE_BUFFER_SIZE);
	virtual ~CStaticSimpleDataBufferT() {  }

public:
	DWORD GetSize() const { return m_dwDataLen; }
	DataTypePointer GetData() { return m_sData ;}
	ConstDataTypePointer GetData() const { return m_sData ;}
	BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize);
	DWORD GetMaxSize() const {  return m_dwMaxDataSize; }
	void  Clear() { m_dwDataLen = 0; }

private:
	DataType m_sData[MAX_STATIC_SIMPLE_BUFFER_SIZE];
	DWORD   m_dwDataLen;
	const DWORD m_dwMaxDataSize;		
};

        从实现的代码看，静态缓冲区就是在内存中事先分配好一段空间，这种分配一般是在栈中进行，分配速度特别快，但是不灵活，不能按照用户的大小需求分配空间。

3.动态缓冲区

        动态缓冲区类通常基于动态内存分配（如new和delete)来满足用户的需求。静态缓冲区的大小在编译时确定，而动态缓冲区的大小则根据需要动态变化。静态缓冲区适用于那些大小已知且不会改变的场景，而动态缓冲区则更灵活，适用于大小可能变化的场景。动态缓冲区类CDynamicSimpleDataBufferT实现代码如下：

//CSimpleDataBufferBase的默认适配器
template <class T>
class  CSimpleDataBufferAdapter : public CSimpleDataBufferBase<T>
{
public:
	CSimpleDataBufferAdapter() : m_pData(NULL),m_dwDataLen(0) { }
	virtual ~CSimpleDataBufferAdapter() { }

public:
	DWORD GetSize() const { return m_dwDataLen; }
	BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize) {  assert(0); return FALSE; }
	void  SetSize(DWORD dwSize) { m_dwDataLen = dwSize; }
	DWORD GetMaxSize() const {  assert(0); return 0; }
	void  Clear() {  assert(0); }
	DataTypePointer GetData() { return m_pData ;}
	ConstDataTypePointer GetData() const { return m_pData ;}
	
protected:
	DataTypePointer  m_pData;
	DWORD   m_dwDataLen;	
};

/动态缓冲区
template <class T>
class  CDynamicSimpleDataBufferT : public CSimpleDataBufferAdapter<T>
{
public:
	CDynamicSimpleDataBufferT(DWORD dwMaxSize = MAX_DYNAMIC_SIMPLE_BUFFER_SIZE);
	virtual ~CDynamicSimpleDataBufferT() { ClearData(); }

public:
	void  Clear() {  m_dwDataLen = 0; }
	DWORD GetMaxSize() const { return m_dwMaxDataSize; }
	BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize);

protected:
	void  ClearData();

private:
	const DWORD m_dwMaxDataSize;
};

构造函数、析构函数、赋值函数实现如下：

//构造函数
template <class T>
CDynamicSimpleDataBufferT<T>::CDynamicSimpleDataBufferT(DWORD dwMaxSize)
: m_dwMaxDataSize(dwMaxSize)
{
	m_pData = new T[dwMaxSize];
	if (m_pData == NULL)
		throw std::	bad_alloc("new T Array Failed");
	m_dwDataLen = 0;
	
	assert(m_pData != NULL);
	assert(m_dwDataLen >= 0);
}

//清空数据函数
template <class T>
void  CDynamicSimpleDataBufferT<T>::ClearData()
{
	if (m_pData)
		delete []m_pData;

	m_pData = NULL;
	m_dwDataLen = 0;
}

//赋值函数
template <class T>
BOOL CDynamicSimpleDataBufferT<T>::SetData(ConstDataTypePointer pData, DWORD dwSize)
{
	int  i;

	if (dwSize > m_dwMaxDataSize)
		return FALSE;

	for (i = 0; i < (int)dwSize; i++)
		m_pData[i] = pData[i];
	m_dwDataLen = dwSize;

	return TRUE;
}

        析构函数自动调用了Clear函数，释放了内存，这样就不怕退出的时候出现内存泄漏。

4.数据引用类

        在前面讲解的静态缓冲区和动态缓冲区内部都需要开辟空间，而数据引用类不需要开辟空间；CRefSimpleDataBufferT的具体实现如下：

template <class T>
class  CRefSimpleDataBufferT : public CSimpleDataBufferAdapter<T>
{
public:
	CRefSimpleDataBufferT() { }
	CRefSimpleDataBufferT(ConstDataTypePointer pBuffer, DWORD dwSize);
	virtual ~CRefSimpleDataBufferT()  {  }

public:
	BOOL  SetData(ConstDataTypePointer pBuffer, DWORD dwSize);
	void  Clear();
};

template <class T>
CRefSimpleDataBufferT<T>::CRefSimpleDataBufferT(ConstDataTypePointer pBuffer, DWORD dwSize)
{
	m_pData = const_cast<DataTypePointer>(pBuffer);
	m_dwDataLen = dwSize;
}

template <class T>
void CRefSimpleDataBufferT<T>::Clear()
{
	if (m_pData)
		delete []m_pData;
	
	m_pData = NULL;
	m_dwDataLen = 0;
}

template <class T>
BOOL  CRefSimpleDataBufferT<T>::SetData(typename CRefSimpleDataBufferT<T>::ConstDataTypePointer pBuffer, DWORD dwSize)
{
	Clear();

	m_pData = const_cast<DataTypePointer>(pBuffer);
	m_dwDataLen = dwSize;

	return TRUE;
}

从实现的代码来看，如果引用的数据是动态分配的，就可以调用Clear函数释放内存，反之，则不需要调用。

5.自动数据引用类

自动数据引用类就是引用外部的动态分配的数据源，并自动释放这个数据源的内存。CAutoRefSimpleDataBufferT的实现代码如下：

//自动释放动态分配的数据引用类
template <class T>
class  CAutoRefSimpleDataBufferT : public CRefSimpleDataBufferT<T>
{	
public:
	CAutoRefSimpleDataBufferT() { }
	CAutoRefSimpleDataBufferT(ConstDataTypePointer pBuffer, DWORD dwSize);
	CAutoRefSimpleDataBufferT(ConstDataTypePointer pBuffer);
	void  Clear();
	DataTypePointer   operator->() { return GetData(); }
	ConstDataTypePointer   operator->() const  { return GetData(); }
	virtual ~CAutoRefSimpleDataBufferT();
};

template <class T>
CAutoRefSimpleDataBufferT<T>::CAutoRefSimpleDataBufferT(typename CAutoRefSimpleDataBufferT<T>::ConstDataTypePointer pBuffer, DWORD dwSize)
: CRefSimpleDataBufferT<T>(pBuffer, dwSize)
{
}

template <class T>
CAutoRefSimpleDataBufferT<T>::CAutoRefSimpleDataBufferT(typename CAutoRefSimpleDataBufferT<T>::ConstDataTypePointer pBuffer)
: CRefSimpleDataBufferT<T>(pBuffer, 1)
{
}

template <class T>
void CAutoRefSimpleDataBufferT<T>::Clear()
{
	if (1 == m_dwDataLen)
		delete m_pData;
	else
		CRefSimpleDataBufferT<T>::Clear();
}

template <class T>
CAutoRefSimpleDataBufferT<T>::~CAutoRefSimpleDataBufferT()
{
	Clear();
}

CAutoRefSimpleDataBufferT和CRefSimpleDataBufferT的不同点就在于析构函数自动调用了Clear函数，释放了数据源的内存。

6.几种缓冲区的类关系图

7.注意事项

1）静态成员变量的初始化：静态成员变量需要在类外进行初始化，并且只能初始化一次。

2）线程安全：如果多个线程可能同时访问这个静态缓冲区，你需要实现适当的同步机制来避免数据竞争和不一致。

3）资源管理：静态缓冲区在程序结束时自动销毁，但如果你在其中存储了动态分配的资源（如指针指向的堆内存），你需要确保在程序结束前正确释放这些资源。

4）性能考虑：静态缓冲区大小固定，如果缓冲区大小设置不当，可能会导致频繁的内存溢出或内存浪费。

5）并发访问：在并发环境中，如果多个线程可能同时写入或读取缓冲区，需要考虑使用互斥锁（如std::mutex）来同步访问。

8.完整代码

Noncopyable.h

/*************************************************************************

// 功能: 防止拷贝类

// 备注: 

*************************************************************************/
#pragma once

class  CNoncopyable
{
public:
	CNoncopyable() {}
	~CNoncopyable() {}

protected:
	CNoncopyable(const CNoncopyable& src);  //拷贝构造函数
	const CNoncopyable& operator=(const CNoncopyable& src); //赋值函数
};

SimpleDataBuffer.h

#pragma once
#include "Noncopyable.h"
#include <assert.h>
#include <new>
#include <stdexcept>
using namespace std;

#define  MAX_STATIC_SIMPLE_BUFFER_SIZE  	  (4*1024)  //4K
#define  MAX_DYNAMIC_SIMPLE_BUFFER_SIZE       (800*1024) //800K

template <class T>
class CSimpleDataBufferBase : public CNoncopyable
{
public:
	typedef T  DataType;
	typedef T* DataTypePointer;
	typedef T& DataTypeReference;
	typedef const T ConstDataType;
	typedef const T* ConstDataTypePointer;
	typedef const T& ConstDataTypeReference;
	
public:
	CSimpleDataBufferBase() {}
	virtual ~CSimpleDataBufferBase() {}

public:
	virtual  DWORD GetSize() const = 0;
	virtual  DataTypePointer GetData() = 0;
	virtual  ConstDataTypePointer GetData() const = 0;
	virtual  DWORD GetMaxSize() const = 0;
	operator DataTypePointer() {  return GetData(); } 
	DataTypeReference operator*() { return *GetData(); }
	DataTypeReference operator[](int nIndex);
	virtual  BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize) = 0;
	virtual  void  SetSize(DWORD dwSize) = 0;
	virtual  void  Clear() = 0;
};

template <class T>
typename CSimpleDataBufferBase<T>::DataTypeReference CSimpleDataBufferBase<T>::operator[](int nIndex)
{
	if ( (nIndex >= 0) && (nIndex < (int)GetSize()))
	{
		DataTypePointer pData = GetData();
		return pData[nIndex];
	}
	else
	{
		throw std::out_of_range("invalid data<nIndex> position");
	}	
}

//数据静态分配
template <class T>
class CStaticSimpleDataBufferT : public CSimpleDataBufferBase<T>
{
public:
	CStaticSimpleDataBufferT(DWORD dwMaxSize = MAX_STATIC_SIMPLE_BUFFER_SIZE);
	virtual ~CStaticSimpleDataBufferT() {  }

public:
	DWORD GetSize() const { return m_dwDataLen; }
	DataTypePointer GetData() { return m_sData ;}
	ConstDataTypePointer GetData() const { return m_sData ;}
	BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize);
	void  SetSize(DWORD dwSize) { m_dwDataLen = dwSize; }
	DWORD GetMaxSize() const {  return m_dwMaxDataSize; }
	void  Clear() { m_dwDataLen = 0; }

private:
	DataType m_sData[MAX_STATIC_SIMPLE_BUFFER_SIZE];
	DWORD   m_dwDataLen;
	const DWORD m_dwMaxDataSize;		
};

template <class T>
CStaticSimpleDataBufferT<T>::CStaticSimpleDataBufferT(DWORD dwMaxSize)
:  m_dwDataLen(0),
   m_dwMaxDataSize(dwMaxSize)
{
}

template <class T>
BOOL  CStaticSimpleDataBufferT<T>::SetData(ConstDataTypePointer pData, DWORD dwSize)
{
	int  i;
	if (dwSize > m_dwMaxDataSize)
		return FALSE;

	for (i = 0; i < (int)dwSize; i++)
		m_sData[i] = pData[i];
	m_dwDataLen = dwSize;
	
	return TRUE;
}
///
template <class T>
class  CSimpleDataBufferAdapter : public CSimpleDataBufferBase<T>
{
public:
	CSimpleDataBufferAdapter() : m_pData(NULL),m_dwDataLen(0) { }
	virtual ~CSimpleDataBufferAdapter() { }

public:
	DWORD GetSize() const { return m_dwDataLen; }
	BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize) {  assert(0); return FALSE; }
	void  SetSize(DWORD dwSize) { m_dwDataLen = dwSize; }
	DWORD GetMaxSize() const {  assert(0); return 0; }
	void  Clear() {  assert(0); }
	DataTypePointer GetData() { return m_pData ;}
	ConstDataTypePointer GetData() const { return m_pData ;}
	
protected:
	DataTypePointer  m_pData;
	DWORD   m_dwDataLen;	
};

/
template <class T>
class  CDynamicSimpleDataBufferT : public CSimpleDataBufferAdapter<T>
{
public:
	CDynamicSimpleDataBufferT(DWORD dwMaxSize = MAX_DYNAMIC_SIMPLE_BUFFER_SIZE);
	virtual ~CDynamicSimpleDataBufferT() { ClearData(); }

public:
	void  Clear() {  m_dwDataLen = 0; }
	DWORD GetMaxSize() const { return m_dwMaxDataSize; }
	BOOL  SetData(ConstDataTypePointer pData, DWORD dwSize);

protected:
	void  ClearData();

private:
	const DWORD m_dwMaxDataSize;
};

template <class T>
CDynamicSimpleDataBufferT<T>::CDynamicSimpleDataBufferT(DWORD dwMaxSize)
: m_dwMaxDataSize(dwMaxSize)
{
	m_pData = new T[dwMaxSize];
	if (m_pData == NULL)
		throw std::	bad_alloc("new T Array Failed");
	m_dwDataLen = 0;
	
	assert(m_pData != NULL);
	assert(m_dwDataLen >= 0);
}

template <class T>
void  CDynamicSimpleDataBufferT<T>::ClearData()
{
	if (m_pData)
		delete []m_pData;

	m_pData = NULL;
	m_dwDataLen = 0;
}

template <class T>
BOOL CDynamicSimpleDataBufferT<T>::SetData(ConstDataTypePointer pData, DWORD dwSize)
{
	int  i;

	if (dwSize > m_dwMaxDataSize)
		return FALSE;

	for (i = 0; i < (int)dwSize; i++)
		m_pData[i] = pData[i];
	m_dwDataLen = dwSize;

	return TRUE;
}
//
template <class T>
class  CRefSimpleDataBufferT : public CSimpleDataBufferAdapter<T>
{
public:
	CRefSimpleDataBufferT() { }
	CRefSimpleDataBufferT(ConstDataTypePointer pBuffer, DWORD dwSize);
	virtual ~CRefSimpleDataBufferT()  {  }

public:
	BOOL  SetData(ConstDataTypePointer pBuffer, DWORD dwSize);
	void  Clear();
};

template <class T>
CRefSimpleDataBufferT<T>::CRefSimpleDataBufferT(ConstDataTypePointer pBuffer, DWORD dwSize)
{
	m_pData = const_cast<DataTypePointer>(pBuffer);
	m_dwDataLen = dwSize;
}

template <class T>
void CRefSimpleDataBufferT<T>::Clear()
{
	if (m_pData)
		delete []m_pData;
	
	m_pData = NULL;
	m_dwDataLen = 0;
}

template <class T>
BOOL  CRefSimpleDataBufferT<T>::SetData(typename CRefSimpleDataBufferT<T>::ConstDataTypePointer pBuffer, DWORD dwSize)
{
	Clear();

	m_pData = const_cast<DataTypePointer>(pBuffer);
	m_dwDataLen = dwSize;

	return TRUE;
}

//自动释放动态分配的数据引用类
template <class T>
class  CAutoRefSimpleDataBufferT : public CRefSimpleDataBufferT<T>
{	
public:
	CAutoRefSimpleDataBufferT() { }
	CAutoRefSimpleDataBufferT(ConstDataTypePointer pBuffer, DWORD dwSize);
	CAutoRefSimpleDataBufferT(ConstDataTypePointer pBuffer);
	void  Clear();
	DataTypePointer   operator->() { return GetData(); }
	ConstDataTypePointer   operator->() const  { return GetData(); }
	virtual ~CAutoRefSimpleDataBufferT();
};

template <class T>
CAutoRefSimpleDataBufferT<T>::CAutoRefSimpleDataBufferT(typename CAutoRefSimpleDataBufferT<T>::ConstDataTypePointer pBuffer, DWORD dwSize)
: CRefSimpleDataBufferT<T>(pBuffer, dwSize)
{
}

template <class T>
CAutoRefSimpleDataBufferT<T>::CAutoRefSimpleDataBufferT(typename CAutoRefSimpleDataBufferT<T>::ConstDataTypePointer pBuffer)
: CRefSimpleDataBufferT<T>(pBuffer, 1)
{
}

template <class T>
void CAutoRefSimpleDataBufferT<T>::Clear()
{
	if (1 == m_dwDataLen)
		delete m_pData;
	else
		CRefSimpleDataBufferT<T>::Clear();
}

template <class T>
CAutoRefSimpleDataBufferT<T>::~CAutoRefSimpleDataBufferT()
{
	Clear();
}
流星雨爱编程
关注
专栏目录
C++线程安全类
程序员光剑
07-31 1766
C++是多种编程语言中功能最丰富、性能最高的语言之一。在不少情况下，当涉及到多个线程访问同一个资源的时候，线程安全问题就不可避免地出现了。因此，为了解决线程安全问题，我们需要掌握一些线程安全类的知识。本文将对C++中的线程安全类进行分类、介绍其基本概念、技术原理及使用方法。1998年3月2日，由史蒂夫·乔布斯、比尔·盖茨、乔纳森·弗里德曼、莱昂纳多·迪卡普里奥等创办的苹果公司发布了iPhone手机，作为史上第一部支持多任务处理、运行图形用户界面应用软件的触摸屏智能手机。
通用循环缓冲区类(c++版)
程序猿老樊的博客
05-12 736
在多种应用场景下，如网络通信、数据流处理和实时系统中，循环缓冲区（又称环形缓冲区、圆形缓冲区或者循环队列）是一个非常有用的数据结构。它允许缓冲区在被填满之后，自动从起始位置开始重写数据，从而实现一个连续的数据流处理。本文将介绍如何在C++中实现一个通用的循环缓冲区类（），并确保其高效性和类型安全性。
C++ 环形缓冲区（队列）简单实现
thequitesunshine007的博客
10-25 2738
1. 说明 在实际工作中，如果数据流量过大，可以先把数据接收到数据缓冲区中，处理之后再取出。我们定义的包协议可以采用定长包，可以采用不定长度的包，环形缓冲区都能处理。 2. 使用场景 2.1 生产消费的场所 在 “生产者--消费者”模式中，往往会用到这种环形缓冲区的功能。 2.2 线程间高速通信的场所 3. 使用的局限性 主要适用于单向传输。不太适用于双向传输的情形。 4. 代码展示 CircleBuffer.h #pragma once # include <stdint.h&
C++环形缓冲区设计与实现：从原理到应用的全方位解析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-28 2496
C++环形缓冲区设计与实现：从原理到应用的全方位解析
C++环形缓冲区的简单实现
04-03 2661
分享一个在工作中用到的简单的环形缓冲区。构造简单，可以改造到Qt中使用，也可以直接在VS下使用。 所谓环形缓冲区，其实就是带有标识缓冲区中数据头、尾位置的缓冲区，这个缓冲区根据业务的不同，要设置的稍微大一点，不能一有数据过来就填满了，这样就失去使用的意义了。 在实际工作中，我们使用TCP和设备进行通信，如果数据流量过大，可以先把数据接收到数据缓冲区中，处理之后再取出。我们定义的包协议可以采用定...
c++实现一个简易的网络缓冲区
shi_xiao_xuan的博客
12-24 4403
简单的网络区设计与实现 1）.为什么需要设计网络缓冲区，内核中不是有读写缓冲区吗？ 2）.缓冲区应该设置为堆内存还是栈内存？ 3）.读写缓冲区的基本要求是什么？ 4）.如何界定数据包？ 5）.几种常见的缓冲区设计
C++ 队列与缓冲区
river.qu
06-13 3789
阻塞式消息队列、消息数据缓冲区、环形缓冲区、在自定义应用层协议中的应用..
C++编程对缓冲区的理解
jake824慢慢磨
11-02 4387
什么是缓冲区 　   缓冲区又称为缓存，它是内存空间的一部分。也就是说，在内存空间中预留了一定的存储空间，这些存储空间用来缓冲输入或输出的数据，这部分预留的空间就叫做缓冲区。　　       缓冲区根据其对应的是输入设备还是输出设备，分为输入缓冲区和输出缓冲区。   为什么要引入缓冲区 　　比如我们从磁盘里取信息，我们先把读出的数据放在缓冲区，计算机再直接从缓冲区中取
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 66万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
C语言, C++ IO 总结. 一篇文章帮你透析缓冲区存在的意义, C, C++ IO的常见用法
小杰312的博客
02-11 2510
C语言, C++ IO 总结. 一篇文章帮你透析缓冲区存在的意义, C, C++ IO的常见用法
一个封装好的C++环形缓冲区
11-30
### 知识点详解：C++中的环形缓冲区实现 #### 1. 环形缓冲区概念 ...综上所述，`CircleBuffer`类提供了一种高效且灵活的方式来管理和操作固定大小的数据缓冲区，是C++程序设计中一个实用的工具。
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 992
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 972
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 473
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 858
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
ARM 之十八 详解 MDK、IAR、Eclipse 的 C 标准库及重定向输入输出
技术干货
09-23 124
在嵌入式系统开发中，我们通常会将标准输入输出作为一个控制台功能添加到我的嵌入式应用程序中。这样我就有了一个命令行接口，可以检查和修改目标系统。我们最常用的方法就是将标准输入输出进行重定向，今天就来重点学习一下！
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 671
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
简易STL实现 | Set 的实现
最新发布
AsherGu的博客
09-26 279
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
Python对于C语言使用者来说的反直觉特性
m0_62710548的博客
09-22 729
在编程领域，从一种语言转向另一种语言总是伴随着一系列的学习和调整。对于习惯了C语言严谨性的程序员来说，转向Python可能会遇到一些令人惊讶的特性。以下是我在短暂学习了一段时间python后察觉到的一些python的特性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值