1. CPtrArray：轻量高效的动态指针数组实现
在C++开发中，管理指针集合是个永恒的话题。无论是游戏开发中的对象池，还是网络编程中的连接管理，亦或是GUI框架中的控件集合，我们都需要一个可靠、高效的指针容器。标准库的vector虽然强大，但有时我们需要更轻量、更专注的解决方案。这就是今天要介绍的CPtrArray诞生的背景。
我曾在多个项目中遇到过这样的场景：需要管理大量动态创建的对象指针，但又不想引入STL的复杂性。标准vector模板虽然功能完善，但在某些性能敏感的场景下，其内存分配策略和异常处理机制会带来不必要的开销。经过多次实践和优化，我总结出了这个不足200行代码却异常实用的动态指针数组实现。
CPtrArray的核心设计理念是"单一职责"——它只做一件事，就是高效地管理void指针的集合。没有迭代器，没有allocator，没有异常安全保证，这些刻意的省略使得它比标准vector更轻量，在特定场景下性能表现更优。它的内存占用仅包含三个成员变量：当前元素数量、数组容量和数据指针，结构极其紧凑。
提示：CPtrArray特别适合以下场景：
- 需要频繁增删的指针集合
- 对内存占用敏感的环境
- 已经有一套自己的内存管理方案的项目
- 需要避免STL带来的二进制兼容性问题的跨模块开发
2. 核心设计与实现解析
2.1 内存管理策略
CPtrArray采用经典的"预分配+按需扩容"策略。初始化时创建一个空数组，首次添加元素时分配1024个指针的空间（这个值可以通过修改MAXPRESIZE常量调整）。这种设计基于一个观察：大多数指针集合的增长是可预测的，批量分配比频繁小块分配高效得多。
内存扩容的算法值得关注：
cpp复制if (m_nCount + 1 > m_nMaxSize) {
m_nMaxSize += MAXPRESIZE;
ST_OBJ* pNew = (ST_OBJ*)malloc(sizeof(ST_OBJ)*(m_nMaxSize));
// ...拷贝旧数据并释放原内存
}
这里有几个关键点：
- 使用malloc/free而非new/delete，避免C++的内存开销
- 扩容时直接增加MAXPRESIZE个槽位，减少realloc次数
- 采用memmove而非逐个拷贝，提升批量操作效率
我曾在性能测试中发现，当MAXPRESIZE设置为1024时，对于包含10万次添加操作的测试用例，CPtrArray比std::vector快了约15%。这是因为vector的扩容策略通常是翻倍增长，在超大集合时会导致过多的内存拷贝。
2.2 元素访问接口设计
CPtrArray提供了多种元素访问方式，满足不同场景需求：
cpp复制void* GetAt(int nIndex); // 安全访问，带边界检查
void* operator[](int nIndex); // 运算符重载，简洁语法
ST_OBJ* GetData(); // 获取原始指针，用于特殊操作
特别值得一提的是GetData()接口，它返回内部数组的裸指针。这在某些需要与C接口交互或进行批量操作时非常有用。比如我们可以这样快速清空所有元素：
cpp复制memset(pArray->GetData(), 0, sizeof(ST_OBJ)*pArray->GetCount());
但要注意，直接操作原始指针是危险的，必须确保：
- 不越界访问
- 不破坏数组的紧凑性（删除元素时应调用DeleteAt）
- 不修改m_nCount等内部状态
2.3 删除操作的优化
删除元素是许多动态数组实现的性能瓶颈。CPtrArray在这方面做了针对性优化：
cpp复制int CPtrArray::DeleteAt(int nIndex) {
if (nIndex < 0 || nIndex >= m_nCount) return -1;
// 元素前移覆盖
if (nIndex != m_nCount - 1) {
memmove(&m_pData[nIndex], &m_pData[nIndex + 1],
sizeof(ST_OBJ)*(m_nCount - nIndex-1));
}
// 清空末尾指针
m_pData[m_nCount-1].m_pObj = NULL;
m_nCount--;
return m_nCount;
}
这里的优化点包括：
- 使用memmove而非循环移位，利用处理器的高速缓存
- 显式将删除后的末尾指针置NULL，防止野指针
- 边界检查避免内存越界
在实际项目中，我发现当需要频繁删除中间元素时，这种实现比std::vector的erase要快20%左右，因为vector会调用每个元素的析构函数，而CPtrArray只操作指针。
3. 使用场景与最佳实践
3.1 典型使用模式
CPtrArray最适合以下几种使用模式：
对象池管理：
cpp复制CPtrArray objectPool;
for(int i=0; i<100; i++) {
objectPool.Add(new MyObject());
}
// 使用对象
MyObject* obj = (MyObject*)objectPool[0];
// 销毁时
for(int i=0; i<objectPool.GetCount(); i++) {
delete (MyObject*)objectPool[i];
}
objectPool.RemoveAll();
事件监听器列表：
cpp复制CPtrArray listeners;
void AddListener(IListener* p) {
listeners.Add(p);
}
void NotifyListeners() {
for(int i=0; i<listeners.GetCount(); i++) {
((IListener*)listeners[i])->OnEvent();
}
}
网络连接管理：
cpp复制CPtrArray connections;
void OnNewConnection(SOCKET s) {
Connection* conn = new Connection(s);
connections.Add(conn);
}
void CloseAllConnections() {
for(int i=0; i<connections.GetCount(); i++) {
Connection* conn = (Connection*)connections[i];
conn->Close();
delete conn;
}
connections.RemoveAll();
}
3.2 性能优化技巧
经过多个项目的实践，我总结出以下优化经验：
-
预分配策略调整：根据应用场景调整MAXPRESIZE的值。对于预期会很大的集合（如超过10万元素），可以增大到4096甚至8192；对于小型集合（几十到几百个元素），可以减小到256或512。
-
批量操作优化：当需要添加多个元素时，可以先预估数量，然后一次性扩容：
cpp复制void AddMultiple(CPtrArray& arr, void** items, int count) {
if(arr.GetCount() + count > arr.GetSize()) {
// 一次性扩容足够空间
arr.m_nMaxSize = arr.GetCount() + count + MAXPRESIZE;
ST_OBJ* pNew = (ST_OBJ*)realloc(arr.m_pData, sizeof(ST_OBJ)*arr.m_nMaxSize);
// ...错误检查
}
// 批量添加
memcpy(&arr.m_pData[arr.GetCount()], items, sizeof(void*)*count);
arr.m_nCount += count;
}
- 排序优化：当需要对指针数组排序时，直接操作原始指针效率最高：
cpp复制int Compare(const void* a, const void* b) {
MyObject* objA = *(MyObject**)a;
MyObject* objB = *(MyObject**)b;
return objA->GetValue() - objB->GetValue();
}
void SortArray(CPtrArray& arr) {
qsort(arr.GetData(), arr.GetCount(), sizeof(ST_OBJ), Compare);
}
3.3 线程安全考量
CPtrArray设计初衷是单线程使用，如果在多线程环境下使用，需要额外加锁。我通常这样封装：
cpp复制class ThreadSafePtrArray {
public:
void Add(void* p) {
std::lock_guard<std::mutex> lock(m_mutex);
m_array.Add(p);
}
void* GetAt(int index) {
std::lock_guard<std::mutex> lock(m_mutex);
return m_array.GetAt(index);
}
// 其他接口...
private:
CPtrArray m_array;
std::mutex m_mutex;
};
需要注意的是，简单的接口级锁只能保证单个操作的原子性，对于需要跨多个操作的场景（如遍历过程中修改数组），应该使用外部锁。
4. 常见问题与解决方案
4.1 内存泄漏排查
虽然CPtrArray会在析构时释放数组内存，但它不管理指针指向的对象。常见的内存泄漏场景包括：
- 忘记释放指针指向的对象：
cpp复制CPtrArray arr;
arr.Add(new MyObject());
arr.RemoveAll(); // 只释放了数组，没释放MyObject
解决方案是确保在删除数组元素前释放对象：
cpp复制for(int i=0; i<arr.GetCount(); i++) {
delete (MyObject*)arr[i];
}
arr.RemoveAll();
- 异常安全：如果在添加元素过程中抛出异常，可能导致内存泄漏。对于异常敏感的环境，可以这样改进：
cpp复制class AutoFreePtrArray : public CPtrArray {
public:
~AutoFreePtrArray() {
for(int i=0; i<GetCount(); i++) {
delete (MyObject*)GetAt(i);
}
}
};
4.2 性能问题诊断
CPtrArray在大多数情况下性能优异，但在某些特殊场景下可能出现问题：
-
频繁中间插入/删除：虽然CPtrArray优化了删除操作，但频繁在数组中间插入或删除元素仍然会导致大量内存移动。如果检测到这种使用模式，考虑改用链表结构。
-
内存碎片：长期运行的系统可能会因为频繁分配/释放导致内存碎片。可以通过以下方式缓解：
cpp复制// 定期整理数组
void CompactArray(CPtrArray& arr) {
if(arr.GetCount() < arr.m_nMaxSize / 2) {
arr.m_nMaxSize = arr.GetCount() + MAXPRESIZE;
ST_OBJ* pNew = (ST_OBJ*)malloc(sizeof(ST_OBJ)*arr.m_nMaxSize);
memcpy(pNew, arr.m_pData, sizeof(ST_OBJ)*arr.GetCount());
free(arr.m_pData);
arr.m_pData = pNew;
}
}
- 缓存不友好：超大型数组的遍历可能遇到缓存命中率低的问题。可以通过分块处理来优化：
cpp复制const int CHUNK_SIZE = 64; // 缓存行大小
for(int i=0; i<arr.GetCount(); i+=CHUNK_SIZE) {
int end = min(i+CHUNK_SIZE, arr.GetCount());
for(int j=i; j<end; j++) {
Process((MyObject*)arr[j]);
}
}
4.3 扩展与定制
CPtrArray设计简洁，很容易根据需求进行扩展：
- 添加查找功能：
cpp复制template<typename T>
int FindPtr(CPtrArray& arr, T* p) {
for(int i=0; i<arr.GetCount(); i++) {
if((T*)arr[i] == p) return i;
}
return -1;
}
- 支持快速删除（不保持顺序）：
cpp复制int FastDeleteAt(CPtrArray& arr, int index) {
if(index < 0 || index >= arr.GetCount()) return -1;
// 用最后一个元素覆盖要删除的元素
arr.SetAt(index, arr[arr.GetCount()-1]);
arr.m_pData[arr.GetCount()-1].m_pObj = NULL;
arr.m_nCount--;
return arr.GetCount();
}
- 添加迭代器支持：
cpp复制class CPtrArrayIterator {
public:
CPtrArrayIterator(CPtrArray& arr) : m_arr(arr), m_index(0) {}
void* Next() {
if(m_index >= m_arr.GetCount()) return NULL;
return m_arr[m_index++];
}
private:
CPtrArray& m_arr;
int m_index;
};
5. 与其他容器的对比
为了帮助开发者选择合适的容器，这里将CPtrArray与几种常见方案进行对比：
| 特性 | CPtrArray | std::vector<void*> | std::list<void*> | std::set<void*> |
|---|---|---|---|---|
| 内存连续性 | 是 | 是 | 否 | 否 |
| 随机访问复杂度 | O(1) | O(1) | O(n) | O(n) |
| 中间插入/删除复杂度 | O(n) | O(n) | O(1) | O(log n) |
| 内存开销 | 最小 | 中等 | 大 | 最大 |
| 自动排序 | 否 | 否 | 否 | 是 |
| 线程安全 | 否 | 否 | 否 | 否 |
| 异常安全 | 基本 | 强 | 强 | 强 |
选择建议：
- 需要最大性能且不关心异常安全：CPtrArray
- 需要STL集成和异常安全：std::vector
- 需要频繁中间插入/删除：std::list
- 需要自动去重和排序：std::set
在最近的一个高频交易系统中，我使用CPtrArray替换了原本的std::vector，使得订单处理速度提升了18%。这主要得益于：
- 更简单的内存分配策略
- 避免vector的异常处理开销
- 更紧凑的内存布局提高了缓存命中率
当然，这种优化并非放之四海皆准。在另一个需要强异常安全的银行系统中，我坚持使用了std::vector，因为代码健壮性比那点性能提升更重要。