自己的底层代码库（六）——对象池

最新推荐文章于 2021-05-26 23:57:31 发布
最新推荐文章于 2021-05-26 23:57:31 发布
阅读量1k 收藏
点赞数
分类专栏： C++ 文章标签： 服务器 内存池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zilaishuichina/article/details/8608606
版权

今天放上 对象池的实现

思路类似于之前的内存池


PS

2013.3.6修改：

去掉了索引树以及搜索功能

因为该功能可以通过TTree来实现，结点分配可以通过new，也可以通过内存池

封装在对象池中反而显得不灵活

索引功能的实现在下一篇文章中做简单介绍


2013.6.26修改：

由于容器、迭代器的修改，做相关调用的调整



和之前内存池的区别：

1、除了使用列表used和空闲列表free之外，另外提供了一个待赋值列表assign

增加assign做用是： 对某个分配出来的结点的赋值操作 和 对使用列表的遍历操作

可以在不同的线程同时执行而不用加锁

申请一个结点（Malloc）后，对结点的赋值操作，在很多情况下可能是异步的

而赋值未完成的结点，通常不希望被遍历处理到或者不希望被Find搜索出来

当开启使用assign列表时，Malloc出来的结点默认是被放入assign列表而不是使用列表used

当赋值完成时需要调用Use()将其放入使用列表

在使用列表中的结点需要中途修改其值时，若不希望在被修改的时候被其他线程遍历或查找

需要调用Assign()将其放回待赋值的列表assign


2、提供遍历的功能

BeginList()表示开始遍历，GetNextUsedObj()获取下一个结点

这两个函数都有加锁，保证遍历的线程安全

但是有一个问题，若GetNextUsedObj()返回出来的结点，在另一个线程中同时被操作了，这个是没有加锁的

若有需要，调用者需要自己另行加锁保证每一个对象的线程安全

若是待遍历的下一个结点，被另一个线程同时操作了（Free或者Assign）

那么（Free或者Assign）会自行将m_pNextLinker后移，保证遍历的正确性


3、因为对象池，其所管理的是同种对象

因此也就不再有元内存块的概念，每个对象所占内存大小是固定的

因此也不再需要内存池中的CMemLinker来管理结点

在对象池中是直接由双链表跟树来管理结点的


详细代码

TObjectAllocator.h

#ifndef _TObjectAllocator_h_
#define _TObjectAllocator_h_

#include <windows.h>

#include "TBDLinkList.h"

#include "tool.h"

//对象池的分配子
template <class T>
class TObjectAllocator
{
public:
	TObjectAllocator();
	~TObjectAllocator();

	//申请一块连续的内存，在这块内存上创建对象管理结点
	//dwObjCount：	容纳的对象个数
	//list：		这些被分配出来的对象需要被放入的链表管理器
public:
	bool Init(DWORD dwObjCount, TBDLinkList<T> &list);

	//释放Init申请的连续的内存
public:
	void Release();

	//判断一个T对象是否是由本分配子分配管理的
	//即计算p的地址值是否在本分配子申请的内存地址区间内
	//是则返回T对应的TBDLinker
	//否则返回NULL
public:
	TBDLinker<T> *GetObjLinker(const T *p);

	//由于分配子用AVL树来管理
	//这里提供2个比较函数函数
	//以及获取关键字的函数
public:
	char *GetKey();
	bool operator==(const char *k);
	bool operator>(const char *k);

private:
	TBDLinker<T> *m_pHead;	//对象链表头指针
	char *m_pStartAddr;	//该分配子申请的m_pHead的起始地址的数值
	char *m_pEndAddr;		//该分配子申请的m_pHead的结束地址的数值
};

#include "TObjectAllocator.hpp"

#endif


TObjectAllocator.hpp

#ifndef _TObjectAllocator_hpp_
#define _TObjectAllocator_hpp_

template <class T>
TObjectAllocator<T>::TObjectAllocator()
{
	m_pHead = NULL;
	m_pStartAddr = NULL;
	m_pEndAddr = NULL;
}

template <class T>
TObjectAllocator<T>::~TObjectAllocator()
{
	Release();
}

template <class T>
bool TObjectAllocator<T>::Init(DWORD dwObjCount, TBDLinkList<T> &list)
{
	if (NULL != m_pHead)
	{
		//该对象现已有所管理的内存，不可以初始化
		return false;
	}
	else if (0 == dwObjCount)
	{
		//初始化参数不正确
		return false;
	}
	else
	{
		//分配内存
		m_pHead = new TBDLinker<T>[dwObjCount];
		if (NULL == m_pHead)
		{
			return false;
		}
		m_pStartAddr = (char *)m_pHead;
		m_pEndAddr = (char *)m_pHead + sizeof(TBDLinker<T>) * dwObjCount - 1;

		//初始化管理结点，放入管理容器
		for (DWORD i = 0; i < dwObjCount; i++)
		{
			m_pHead[i].Init();
			list.PushTail(&(m_pHead[i]));
		}

		return true;
	}
}

template <class T>
void TObjectAllocator<T>::Release()
{
	if (NULL != m_pHead)
	{
		delete[] m_pHead;
		m_pHead = NULL;
		m_pStartAddr = NULL;
		m_pEndAddr = NULL;
	}
}

template <class T>
TBDLinker<T> *TObjectAllocator<T>::GetObjLinker(const T *p)
{
	if (NULL != p)
	{
		TBDLinker<T> *pLinker = ContainerOf(p, TBDLinker<T>, m_Value);
		char *pAddr = (char *)pLinker;
		if (m_pStartAddr <= pAddr && pAddr <= m_pEndAddr)
		{
			if ( 0 == (pAddr - m_pStartAddr) % sizeof(TBDLinker<T>) )
			{
				return pLinker;
			}
		}
	}

	return NULL;
}

template <class T>
char *TObjectAllocator<T>::GetKey()
{
	return m_pStartAddr;
}

template <class T>
bool TObjectAllocator<T>::operator==(const char *k)
{
	if (m_pStartAddr <= k && k <= m_pEndAddr)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template <class T>
bool TObjectAllocator<T>::operator>(const char *k)
{
	if (m_pStartAddr > k)
	{
		return true;
	}
	else
	{
		return false;
	}
}

#endif


TObjectPool.h

#ifndef _TObjectPool_h_
#define _TObjectPool_h_

#include <windows.h>

#include "TBDLinkList.h"
#include "TTree.h"
#include "TObjectAllocator.h"

#include "CLock.h"

#include "tool.h"

enum ObjPoolFlag
{
	enum_EnableAssign = 0,	//是否开启Assign列表
	enum_DisableAssign,
};

//对象池
//
//对象池有3个状态的队列
//可以正常使用的对象列表：m_Used
//分配完毕，但还不能直接使用，正在等待逻辑对其赋值的对象列表：m_Assign
//空闲对象列表：m_Free
//增加m_Assign做用是使 对某个分配出来的结点的赋值操作 和 对使用列表的遍历操作 
//可以在不同的线程同时执行而不用加锁
//对 结点的赋值操作 在很多情况下可能是异步的
//而赋值未完成的结点 通常不希望被遍历处理 或者不希望被Find搜索出来
template <class T>
class TObjectPool
{
public:
	TObjectPool();
	~TObjectPool();

	//初始化函数
	//dwFirstObjCount：	对象池初始分配对象个数
	//					不允许为0
	//dwAddObjCount：	对象池对象不够时，新增分配对象个数，
	//					允许传0，表示对象不够时不开辟新内存，返回空
	//dwLock：			设置是否使用临界区
	//					初始默认为Enable，即使用临界区
	//dwAssignList：	设置是否使用Assign列表
	//					初始默认为Disable，即不使用Assign列表
public:
	bool Init(DWORD dwFirstObjCount, 
		DWORD dwAddObjCount, 
		ContainerFlag dwLock = enum_EnableLock,
		ObjPoolFlag dwAssignList = enum_DisableAssign);

	//释放对象池的所有分配子
public:
	void Release();

	//对象池对象不够时，增加分配子，开辟新内存
private:
	bool AddObject(DWORD dwAddCount);

	//从空闲列表Free得到一个对象结点
	//如果有使用Assign，放入等待赋值列表Assign
	//否则，放入使用列表Used
	//返回获取到的结点所管理的那个对象指针，当没有空闲结点时返回NULL
public:
	T *Malloc();

	//将指定对象从使用列表Used或者等待赋值列表Assign放入空闲列表Free
public:
	bool Free(const T *pObj);

	//当且仅当使用列表Assign时
	//将指定结点从等待赋值列表Assign放入使用列表Used
public:
	bool Use(const T *pObj);

	//当且仅当使用列表Assign时
	//将指定结点从使用列表Used放回等待赋值列表Assign
public:
	bool Assign(const T *pObj);

	//给使用列表Used注册迭代器
	//遍历，获取使用列表Used中的一个T对象
	//这两个函数已加锁
	//在多线程环境下
	//若GetNextUsedObj返回之后的T对象被另一个线程进行了移动（Free或者Assign）
	//暂时需要调用者自行判断或加锁
	//若GetNextUsedObj返回之后下一个待遍历的结点被另一个线程进行了移动
	//m_pNextLinker会自行继续指向下一个，不会出现遍历错误
public:
	void RegisterForUsed(TIterator<T>& iterator);
	void BeginUsedList(TIterator<T>& iterator);
	T *GetNextUsedObj(TIterator<T>& iterator);

	//获取当前各个列表使用情况
public:
	DWORD GetUsedListLen();
	DWORD GetAssignListLen();
	DWORD GetFreeListLen();

private:
	TBDLinkList<T> m_Used;//可以正常使用的对象列表
	TBDLinkList<T> m_Assign;//分配完毕，但还不能直接使用，正在等待赋值的对象列表
	TBDLinkList<T> m_Free;//空闲对象列表

	TTree<char *, TObjectAllocator<T>> m_MemAllocList;//对象池分配子管理链表
	DWORD m_dwAddObjCount;

	ObjPoolFlag m_dwAssignList;	//Assign列表使用开关
	
	CLock m_csLock;		//临界区，保证池操作的线程安全
	ContainerFlag m_dwLock;	//是否使用临界区进行加锁
};

#include "TObjectPool.hpp"

#endif


TObjectPool.hpp

#ifndef _TObjectPool_hpp_
#define _TObjectPool_hpp_

template <class T>
TObjectPool<T>::TObjectPool()
{
	m_Used.Init(enum_DisableLock);
	m_Assign.Init(enum_DisableLock);
	m_Free.Init(enum_DisableLock);

	m_MemAllocList.Init(enum_DisableLock);
	m_dwAddObjCount = 0;

	m_dwAssignList = enum_DisableAssign;

	m_dwLock = enum_EnableLock;
}

template <class T>
TObjectPool<T>::~TObjectPool()
{
	Release();
}

template <class T>
bool TObjectPool<T>::Init(DWORD dwFirstObjCount,
						  DWORD dwAddObjCount,
						  ContainerFlag dwLock,
						  ObjPoolFlag dwAssignList)
{
	if (0 == dwFirstObjCount)
	{
		//初始化参数不正确
		return false;
	}
	else
	{
        Release();
		m_dwAddObjCount = dwAddObjCount;
		m_dwLock = dwLock;
		m_dwAssignList = dwAssignList;

		//申请分配子，开辟第一块内存
		return AddObject(dwFirstObjCount);
	}
}

template <class T>
void TObjectPool<T>::Release()
{
	m_Used.Init(enum_DisableLock);
	m_Assign.Init(enum_DisableLock);
	m_Free.Init(enum_DisableLock);

	TLeaf<char *, TObjectAllocator<T>> *pLeaf = m_MemAllocList.RemoveHead();
	while (NULL != pLeaf)
	{
		delete pLeaf;
		pLeaf = m_MemAllocList.RemoveHead();
	}
	m_MemAllocList.Init(enum_DisableLock);
	m_dwAddObjCount = 0;

	m_dwAssignList = enum_DisableAssign;

	m_dwLock = enum_EnableLock;
}

template <class T>
bool TObjectPool<T>::AddObject(DWORD dwAddCount)
{
	if (0 == dwAddCount)
	{
		return false;
	}
	else
	{
		TLeaf<char *, TObjectAllocator<T>> *pAllocLinker = new TLeaf<char *, TObjectAllocator<T>>;
		if (NULL == pAllocLinker)
		{
			return false;
		}
		pAllocLinker->Init();
		if (!pAllocLinker->m_Value.Init(dwAddCount, m_Free))
		{
			delete pAllocLinker;
			return false;
		}
		pAllocLinker->m_Key = pAllocLinker->m_Value.GetKey();
		m_MemAllocList.Insert(pAllocLinker);

		return true;
	}
}

template <class T>
T  *TObjectPool<T>::Malloc()
{
	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.Lock();
	}

	TBDLinker<T> *pLinker = m_Free.PopHead();
	if (NULL == pLinker)
	{
		if (AddObject(m_dwAddObjCount))
		{
			pLinker = m_Free.PopHead();
		}
	}

	if (NULL == pLinker)
	{
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
		return NULL;
	}
	else
	{
		if (enum_EnableAssign == m_dwAssignList)
		{
			m_Assign.PushTail(pLinker);
		}
		else
		{
			m_Used.PushTail(pLinker);
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}
		return &(pLinker->m_Value);
	}
}

template <class T>
bool TObjectPool<T>::Free(const T *pObj)
{
	if (NULL != pObj)
	{
		bool bRes = false;

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}

		char *pBuffAddr = (char *)pObj;
		TLeaf<char *, TObjectAllocator<T>> *pAllocLinker = m_MemAllocList.Find(pBuffAddr);
		if (NULL != pAllocLinker)
		{
			TBDLinker<T> *pLinker = pAllocLinker->m_Value.GetObjLinker(pObj);
			if (NULL != pLinker)
			{
				if (&m_Used == pLinker->m_pLinkList)
				{
					m_Used.Remove(pLinker);
					m_Free.PushTail(pLinker);
					bRes = true;
				}
				else if (&m_Assign == pLinker->m_pLinkList)
				{
					m_Assign.Remove(pLinker);
					m_Free.PushTail(pLinker);
					bRes = true;
				}
			}
		}
		
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}

		return bRes;
	}

	return false;
}

template <class T>
bool TObjectPool<T>::Use(const T *pObj)
{
	if (NULL != pObj && enum_EnableAssign == m_dwAssignList)
	{
		bool bRes = false;
		
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}
		
		char *pBuffAddr = (char *)pObj;
		TLeaf<char *, TObjectAllocator<T>> *pAllocLinker = m_MemAllocList.Find(pBuffAddr);
		if (NULL != pAllocLinker)
		{
			TBDLinker<T> *pLinker = pAllocLinker->m_Value.GetObjLinker(pObj);
			if (NULL != pLinker)
			{
				if (&m_Assign == pLinker->m_pLinkList)
				{
					m_Assign.Remove(pLinker);
					m_Used.PushTail(pLinker);
					
					bRes = true;
				}
			}
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}

		return bRes;
	}

	return false;
}

template <class T>
bool TObjectPool<T>::Assign(const T *pObj)
{
	if (NULL != pObj && enum_EnableAssign == m_dwAssignList)
	{
		bool bRes = false;
		
		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.Lock();
		}
		
		char *pBuffAddr = (char *)pObj;
		TLeaf<char *, TObjectAllocator<T>> *pAllocLinker = m_MemAllocList.Find(pBuffAddr);
		if (NULL != pAllocLinker)
		{
			TBDLinker<T> *pLinker = pAllocLinker->m_Value.GetObjLinker(pObj);
			if (NULL != pLinker)
			{
				if (&m_Used == pLinker->m_pLinkList)
				{
					m_Used.Remove(pLinker);
					m_Assign.PushTail(pLinker);

					bRes = true;
				}
			}
		}

		if (enum_EnableLock == m_dwLock)
		{
			m_csLock.UnLock();
		}

		return bRes;
	}

	return false;
}

template <class T>
void TObjectPool<T>::RegisterForUsed(TIterator<T>& iterator)
{
	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.Lock();
	}

	iterator.Register(m_Used);

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.UnLock();
	}
}

template <class T>
void TObjectPool<T>::BeginUsedList(TIterator<T>& iterator)
{
	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.Lock();
	}

	iterator.BeginList();

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.UnLock();
	}
}

template <class T>
T *TObjectPool<T>::GetNextUsedObj(TIterator<T>& iterator)
{
	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.Lock();
	}
	
	T *pNext = iterator.GetNext();

	if (enum_EnableLock == m_dwLock)
	{
		m_csLock.UnLock();
	}

	return pNext;
}

template <class T>
DWORD TObjectPool<T>::GetUsedListLen()
{
	return m_Used.GetLen();
}

template <class T>
DWORD TObjectPool<T>::GetAssignListLen()
{
	return m_Assign.GetLen();
}

template <class T>
DWORD TObjectPool<T>::GetFreeListLen()
{
	return m_Free.GetLen();
}

#endif



zilaishuichina
关注
专栏目录
100天精通Python丨基础知识篇 —— 01、C站最全Python标准库总结
独木不成林，单弦不成音。
06-29 51万+
❤粉丝福利：免费下载海量【PPT模板、简历模板、学习资料】https://app.yinxiang.com/fx/13ce6bbd-f36f-4e92-be53-92dd381ed729
100天精通Python丨基础知识篇 —— 07、10个Python高级库总结
热门推荐
独木不成林，单弦不成音。
07-08 5万+
《C站最全Python标准库总结》，登顶了【全站综合热榜】和【python领域热榜】，获得了2362多次点赞、998次评论、2072次收藏，谢谢各位小伙伴。
自己的底层代码库（三）——AVL树
zilaishuichina的专栏
01-29 1491
有段时间没更新，这几周公司在搞一个通讯底层TCP换UDP。 另外之前发的单链表跟双链表的实现中，加锁的位置有问题，误导了大家，今天修正了下加了注释，之前如果看过的同学需要注意下。 今天继续，放上一个AVL树的实现 PS： 2013.2.5修改了树的实现： 1、将关键字K与值域T分离开来，重新更新相关代码，Remove函数以及Find函数（包括后面第四篇的效率测试代码一
对象池原理 php,PHP 设计模式答疑-对象池与依赖注入的区别
weixin_33773084的博客
04-03 97
对象池简单理解对象池应用场景对像池主在对象创建开销较大或要控制对象数量的时候使用。最常见的对象池应该是数据库连接池和线程池。例如：程序需要数据库连接时从连接池中取一个(连接池里有多个连接)，用完了不是关闭连接而是把连接放回连接池给其他程序使用。一个对像池通常只放同一类的对象。为什么有开销较大的说法？首先：对象池服务可以减少从头创建每个对象的系统开销。在需要对象时从池中提取,在使用完对象时，把它放回...
【设计模式】之对象池模式--JDBC连接池简单实现案例
青山师
12-11 814
对象池设计模式 对象池设计模式的目标 对象池可以显著提高性能，在那些初始化一个类实例的代价比较高、但是使用频率比较低的场景时，对象池模式是非常高效的。 问题 对象池(资源池)常用于管理对象缓存。一个客户端通过对象池访问已经存在的实例从而避免创建新的对象。 一般而言，对象池会持续生成对象，例如，如果对象池空了，则会创建新的对象。或者有一个对象池，限制了对象创建的数量。 如果想要保持对象的可重用性，最...
安卓Android源码——网络通信的六种方式示例代码.zip
10-09
这份"安卓Android源码——网络通信的六种方式示例代码"的压缩包提供了多种网络通信方法的实践代码，帮助开发者更好地理解和运用这些技术。下面我们将详细探讨这六种网络通信方式。 1. **HTTP/HTTPS请求**： - **...
android蓝牙底层通道,底层之旅——Android蓝牙系统分析
weixin_28939623的博客
05-26 894
蓝牙系统分为四个层次，内核层、BlueZ库、BlueTooth的适配库、BlueTooth的JNI部分、Java框架层、应用层。下面先来分析Android的蓝牙协议栈。Android的蓝牙协议栈采用BlueZ来实现，BlueZ分为两部分：内核代码和用户态程序及工具集。内核代码主要由BlueZ核心协议和驱动程序组成；蓝牙协议实现在内核源代码net/bluetooth中，驱动程序位于内核源代码目录dr...
C语言标准代码库存档(C库、STL库、Glibc库).zip
09-04
这个压缩包"**C语言标准代码库存档(C库、STL库、Glibc库)**"包含了C语言标准库的重要组成部分，以及两个重要的扩展库——STL库和Glibc库。 C标准库，也被称为ISO C99或C11标准库，是C语言的标准实现，包括了如、、...
谈一谈对象池SafeObjectPool能干什么
weixin_30648587的博客
10-10 543
前言 首先从ado.net的连接池开始了解，数据库操作通常是 new SqlConnection()、 Open()、 使用完后 Close()，整个过程相当耗时，特别是频繁建议套字接连接的过程。ado.net 驱动已经现实了连接池管理，Open() 等于申请连接，Close() 即归还资源。 Open() 的时候有几种情况： 1、有资源直接返回； 2、无可用资源，且未超过池最大设置值时，创建资源...
浅析对象池
rainxu的专栏
06-07 516
在稍微大型一点的软件系统开发中，通常我们会用到内存池，对象池，线程池，连接池等各种各样的池(Pool)，本文就来讲一讲对象池(Object Pool)。下面从四个方面来介绍一下对象池： 1.什么是对象池（Object Pool) ？ 池(Poo), 与集合在某种意义上有些相似。 水池，是一定数量的水的集合；内存池，是一定数量的已经分配好的内存的集合；线程池，是一定数量的已经创建好的线程的集合。
自己的底层代码库（五）——内存池，附加效率测试
zilaishuichina的专栏
02-06 2342
明天回家了~~~~ 今天放上一个内存池的实现，该内存池基于之前发的单链表和双链表。并且参考了Apache内存池的实现。 PS 2013.2.21修改： 将之前的单链表管理的分配子改为AVL树管理 2013.3.1修改： 因为AVL树的结点结构有做修改 内存池也做了相关功能的修改。 主要是内存池分配子的查找操作，bool operator 增加了
自己的底层代码库（八）——获取函数调用堆栈
zilaishuichina的专栏
04-03 6368
今天放上一个工具类，用来获取当前线程/所有线程的当前函数调用堆栈 主要是为了方便用于在打log时，可以将调用堆栈一起输出到文件当中 PS：想打出正确的log是依赖于PDB文件的 类似于VS的向output窗口输出$CALLSTACK 主要用了dbghelp的一些API 参考了： http://www.cnblogs.com/zplutor/archive/2011/04/2
俄罗斯方块
weixin_45422239的博客
03-21 369
unity俄罗斯方块笔记原理思想细节总结原理图C#代码优化方向 原理思想 (1)对象池(提前准备对象进行显示隐藏操作来完成逻辑) (2)矩阵思想(方方正正的地图游戏)、笛卡尔坐标系思想(利用笛卡尔坐标系计算逻辑数据) (3)转换思想 数据转换为对象状态来进行游戏状态切换 数据为0(可移动区域) 1(落地的方块) 2(地图边界) 3(可移动方块) (4)策略思想 大局观 细节剖...
俄罗斯方块游戏中游戏画布和预显画布的实现
Helloway的博客
04-09 1170
俄罗斯方块游戏中游戏画布和预显画布的实现： 1， 建立网格类；  2， 建立画布类；  3， 创建出游戏画布和预显画布并显示。 一、建立网格类： /**  *作     者： Helloway  *类     名：CGrid  *类说明：网格类   */ public class CGrid { private Color gridColor;//设置网格颜色
自己的底层代码库（四）——计时模块，以及效率测试
zilaishuichina的专栏
01-31 1750
测试效率需要计时的模块 所以首先发一下计时模块的代码，用的是QueryPerformanceFrequency跟QueryPerformanceCounter CPerformance.h头文件 #ifndef _CPerformance_h_ #define _CPerformance_h_ #include class CPerformance { public: CPerf
自己的底层代码库（十七）——随机数池
zilaishuichina的专栏
07-09 1666
实际开发过程中，可能会遇到这样的需求：在0到x范围内，生成n（n 这里给出一个简单的实现，其实就是以空间换时间的。 定义长x的数组，对这个数组采用洗牌法打乱顺序，然后顺序的取前n个。 Rand()一下则为重新洗牌。 TRandPool.h #ifndef _TRandPool_h_ #define _TRandPool_h_ #include #incl
面向对象程序设计——C++与OOP深度解析
C++是C语言的一个扩展，它引入了面向对象的特性，同时保留了C语言的底层控制能力。C++的特点在于： 1. 它增强了C语言的数据类型，比如增加了类（class），使得创建复杂数据结构和对象成为可能。 2. 新的语法结构，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值