楼上使用两个静态函数实现了你要的东西，我推敲楼主的意思是否是想用析构函数来自动释放堆申请的内存，
如果是这种场景，使用单例类可以满足：

 class Test
{
    public:
        //带缓冲池的的内存分配实现
        char * allocate(size_t n)
        {
            if( NULL == m_ptrStart){
                //简单考虑最大申请1000，真实场景可使用链表来链接每一块内部申请的大内存；
                m_ptrStart = (char*)::malloc(1000);
                m_ptrCur = m_prtStart;
            }

            char * ptr = m_ptrCur;
            m_ptrCur += n;
            return ptr;
        }

        ~Test() {
            free(m_ptrStart);
            m_ptrStart = NULL;
        }

        static Test * getInstance()
        {
            if(NULL == s_pTest)
                s_pTest = new Test();
            return s_pTest;
        }
    private:
        Test(){m_ptrStart = NULL; m_ptrCur = NULL; }


        char * m_ptrStart;//内存分配首地址
        char * m_ptrCur; //当前未使用的内存
        static Test * s_pTest;//单例
};
Test * Test::s_pTest = NULL;

使用：
char * p1 = Test::getInstance()->allocate(4);
char * p2 = Test::getInstance()->allocate(8);
p1/p2用完后不用释放，单例析构时释放所有内存;

既然你专门写了一个 allocate 来分配内存，为什么不写一个 free 来释放内存呢

 cpp


 #include <iostream>
#include <stdlib.h>

class Test
{
    public:
        static void allocate(size_t n)
        { 
            ptr = (int *)::malloc(n);
            *ptr = 4;
        }

        static void free() {
            free(ptr);
        }

    private:
        static int * ptr; 
};

int*  Test::ptr = nullptr;

int main()
{
    Test::allocate(sizeof(int));
    return 0;
    Test::free();
}

如果你想在析构函数中释放，也不是不可能，但是注意不要重复释放，而且，如果没有对象，就不会产生析构。

 cpp


 ~Test()
        {
            std::cout<< "hello world" << std::endl;
            free(ptr);
            ptr = nullptr;   // <-- 注意这句
        }