C++ *（void**）是什么意思

我在网上看过这样的课， 头锉

#ifndef _COMMON_ARRAY_OBJECT_POOL_H_
#define _COMMON_ARRAY_OBJECT_POOL_H_

#include <stdint.h>

namespace easynet
{

class ArrayObjectPool
{
public:
    /** construct
     * @param elem_size : element size;
     * @param elem_num  : element number
     */
    ArrayObjectPool(uint32_t elem_size, uint32_t elem_num);
    ~ArrayObjectPool();

    uint32_t ElemSize(){return m_ElemSize;}
    uint32_t Capacity(){return m_ElemNum;}
    bool IsEmpty(){return m_FreeHead==NULL;}


    void* Get();


    bool Recycle(void *elem);
private:
    void *m_Elements;
    void *m_End;
    void *m_FreeHead;
    uint32_t m_ElemSize;
    uint32_t m_ElemNum;
};

}
#endif //_COMMON_ARRAY_OBJECT_POOL_H_

#ifndef(公共)数组(对象)池(池)_
#定义(公共)数组(对象)池(池)_
#包括
名称空间easynet
{
类ArrayObject池
{
公众：
/**构造
*@param elem_size:元素大小；
*@param elem_num:元素编号
*/
阵列对象池（uint32元素大小，uint32元素数量）；
~ArrayObjectPool（）；
uint32_t ElemSize（）{return m_ElemSize；}
uint32_t Capacity（）{return m_ElemNum；}
bool IsEmpty（）{return m_FreeHead==NULL；}
void*Get（）；
bool回收（无效*元素）；
私人：
void*m_元素；
void*m_End；
void*m_FreeHead；
uint32_t m_(电);；
uint32元素；
};
}
#endif/\u公共\u数组\u对象\u池\u H_

cpp文件

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

#include "ArrayObjectPool.h"

namespace easynet
{

ArrayObjectPool::ArrayObjectPool(uint32_t elem_size, uint32_t elem_num)
{
    m_ElemNum = elem_num;
    if(elem_size < sizeof(void*))
        m_ElemSize = sizeof(void*);
    else
        m_ElemSize = elem_size;

    m_Elements = malloc(m_ElemSize*m_ElemNum);
    m_End = (void*)((char*)m_Elements+m_ElemSize*m_ElemNum);
    assert(m_Elements != NULL);

    //construct list
    int i;
    void *node = m_Elements;
    for(i=0; i<m_ElemNum-1; ++i)
    {
        *(void**)node = (void*)((char*)node+m_ElemSize);
        node = *(void**)node;
    }
    *(void**)node = NULL;
    m_FreeHead = m_Elements;    //list head
}

ArrayObjectPool::~ArrayObjectPool()
{
    free(m_Elements);
}

void* ArrayObjectPool::Get()
{
    if(m_FreeHead == NULL)
        return NULL;
    void *temp = m_FreeHead;
    m_FreeHead = *(void**)m_FreeHead;
    return temp;
}

bool ArrayObjectPool::Recycle(void *elem)
{
    if(elem<m_Elements || elem>=m_End)
        return false;
    *(void**)elem = m_FreeHead;
    m_FreeHead = elem;
    return true;
}

}

#包括
#包括
#包括
#包括“ArrayObjectPool.h”
名称空间easynet
{
ArrayObjectPool:：ArrayObjectPool（uint32元素大小，uint32元素数量）
{
元素数=元素数；
如果（元素大小for（i=0；iA
void*
是指向非类型化内存的指针值node=…

，它真正做的是

*node=…

。然而，对于后者，您试图将某些内容分配给

无效

，这对C++的类型系统没有意义；您必须像前一种方式一样，将其强制转换为

无效**

，这样

*节点

将是

无效*

，而不是

无效，您可以分配给它

node=*（void**）node
只是
node=*node
但强制类型系统工作。它只是“将
node
处的内存值分配给
*node
解释为
void*
”.
它将内存视为用户数据类型和
void*
之间的一个
联合体。当块位于空闲块列表中时，将使用
void*

你可以这样想：

union ObjectInObjectPool
{
    void* ptr_next_free_block;
    UserType content;
};

然后这个循环基本上在做：

ObjectInObjectPool* node = m_Elements;
for(i=0; i<m_ElemNum-1; ++i) {
    node->ptr_next_free_block = node + 1;
    node = node->ptr_next_free_block;
}

objectnobjectpool*节点=m_元素；
对于（i=0；iptr\u next\u free\u块=node+1；
node=node->ptr\u next\u free\u块；
}

除了程序员手工完成了编译器类型检查器通常所做的所有指针运算。
symbolhound.com适用于搜索，如果google失败*%28void**%29谢谢，我想我理解了（void*）的意思，但for循环的功能是什么？从我的观点来看，它什么都不做（（void*）node=NULL；在for循环之后），在for循环期间，每次节点指针加上一个m_ElemSize范围（例如：4、8、12）。谢谢Ben，这确实帮助我理解了这个类的功能。
ObjectInObjectPool* node = m_Elements;
for(i=0; i<m_ElemNum-1; ++i) {
    node->ptr_next_free_block = node + 1;
    node = node->ptr_next_free_block;
}