关于仿照java的内存回收机制实现C++的自动内存回收的一点想法

#ifndef  __MEM_MALLOC__
#define __MEM_MALLOC__
#include<iostream>
#include<fstream>

//#define _new(h,type) ::new ((type*)h.malloc(sizeof(type))) type()
#define __new__(__heap__,__type__,__init_argv__) ::new ((__type__*)__heap__.malloc(sizeof(__type__))) __type__(__init_argv__)
#define _new(_heap,_type,init_argv) __new__(_heap,_type,init_argv)

#define __delete__(__heap__,__type__,__val__) (__heap__.free((void*)__val__,sizeof(__type__)))
#define _object_del(_heap,_type,_val) (_val)->~_type();__delete__(_heap,_type,_val)
#define _delete(_heap,_type,_val) __delete__(_heap,_type,_val)
class heap{
    char *bit_map;
    char* heap_block;
    int block_size;
    int free_size;
private:
    bool bit_map_set(int loc,int length);
    bool bit_map_clr(int loc,int length);
    int  find_freeblock(int size);
public:
    heap(int size);
    void *malloc(int size){
        int index=this->find_freeblock(size);
        if(index>=0){
            this->bit_map_set(index,size);
            this->free_size-=size;
            //std::cout<<"the free space of my heap has  "<<free_size<<std::endl;
            void * answer=(void*)(this->heap_block+index);
            return answer;
        }
        else{
            return NULL;
        }
    }
    void free(void*p,int size){
        bit_map_clr((int)((char*)p-(this->heap_block)),size);
    }
    void print(std::ostream& out){
        out<<std::hex;
        for(int i=0;i<((this->block_size)-(this->free_size));i+=sizeof(char)){
            out.width(2);
            out.fill(‘0‘);
            out<<((unsigned short)(*(this->heap_block+i))&(0x0f))<<‘ ‘;
        }
        out<<std::dec;
    }
    void source_print(std::ostream& out){
        for(int i=0;i<((this->block_size)-(this->free_size));i+=sizeof(long)){
            out<<std::hex;
            out.width(8);
            out.fill(‘0‘);
            out<<(long*)(this->heap_block+i)<<":";
            out.width(8);
            out.fill(‘0‘);
            out<<((long)(*(this->heap_block+i)))<<std::endl;
        }
        out<<std::dec;
    }
    
        void char_print(std::ostream&out){
            for(int i=0;i<block_size/8;i++){
                out<<std::hex;
                out.widen(2);
                //out.fill(‘0‘);
                out<<"0x"<<(unsigned short)(*(bit_map+i)&0xff)<<" ";

            }
            out<<std::dec<<std::endl;
            
        }
    ~heap(){delete[] heap_block;
    delete[] bit_map;
    }
};
heap::heap(int size){
    heap_block=new char[size];
    bit_map=new char[(int)(size/8.0+0.5)];
    std::fill(bit_map,bit_map+(int)(size/8.0+0.5),0x00);
    block_size=size;
    free_size=size;
    }
bool heap::bit_map_set(int loc,int length){
#define set_bit_at(val,index) (val|(0x01<<(index%8)))
    for(int i=loc;i<loc+length;i++){
        bit_map[i/8]= set_bit_at(bit_map[i/8],i);
    }
    return true;
}
bool heap::bit_map_clr(int loc,int length){
    #define clr_bit_at(val,index) (char)((val)&(~((unsigned char)0x01<<(index%8))))
    for(int i=loc;i<loc+length;i++){
        if(i>=(int)(block_size/8.0+0.5))
            return false;
        bit_map[i/8]= clr_bit_at(bit_map[i/8],i);
    }
    return true;
}
int  heap::find_freeblock(int size){
#define return_bit_at(val,index) (((val>>(index%8))&0x01)==0x01?true:false)
    bool continuation_state=true;
    int count=0;
    int loc=0;
    for(int i=0;i<this->block_size;i++){
        if(!return_bit_at(bit_map[i/8],i)){
            count++;
        }else{
            count=0;
            loc=i;
        }
        if(count>=size)
            return loc;
    }
    return -1;
}

class delete_function{
    heap &_heap;
public:
    delete_function(heap&def_heap):_heap(def_heap){ 
    }
    template<typename T>
    void operator ()(T*p){
    _object_del(_heap,T,p);
    }
    template<typename T>
    void operator ()(heap&def_heap,T*p){
    _object_del(def_heap,T,p);
    }
} ;
class new_function{
        heap &_heap;
public:
    new_function(heap&def_heap):_heap(def_heap){ 
    }
    template<typename T>
    void operator ()(){
    _new(_heap,T);
    }
};
heap default_heap(1024);
delete_function delete_(default_heap);
//new_function   new_(default_heap);
//#define __new(type) _new(Heap,type)
#define        __objdel(_type,_val)                _object_del(Heap,_type,_val)//自定义对象析构
#define            del(_heap_,_val)                                  delete_(_heap_,_val)  //删除在堆Heap上的一个对象
#define            alloc(_heap_,_type,_init_argv)      _new(_heap_,_type,_init_argv)//分配给对象type一块内存
#define    new_(_type_,_init_argv_)     _new(default_heap,_type_,_init_argv_)
#endif 

#pragma once
class NullClass
{
    static int count;
    int id;
public:
    NullClass(void);
    ~NullClass(void);
};

#include "NullClass.h"
#include<iostream>

int NullClass::count=0;
NullClass::NullClass(void)
{
    this->id=count++;
    std::cout<<"创建了id="<<id<<"的一个NullClass对象!"<<std::endl;
}


NullClass::~NullClass(void)
{
    std::cout<<"删除了id="<<id<<"的一个NullClass对象!"<<std::endl;
}

#include<iostream>
#include<string>
#include<vector>
#include<iterator>
#include"NullClass.h"
//%%%%%%%%%%%%%%%%%%%%
#include"pointtype.hpp"
#include"mem_malloc.hpp"
using namespace smart_point;
//%%%%%%%%%%%%%%%%%%%%
using namespace std;
int main(int argc,char*argv[]){
    heap sys_m(1024);
    string*                p1            =        new string("\t这是使用C++提供的方法来动态创建的string对象");
    Ptr<string>        p2            =        new string("\t这将是一个被智能指针Ptr引用的动态创建的string对象!");
    string*                p3            =        new_(string,"\t这是一个用自定义的默认堆创建的string对象!");
    string *            p4            =        alloc(sys_m,string,"\t这是一个使用指定的堆动态创建的string对象!");
    cout<<"p1 ->:"<<*p1<<endl;
    cout<<"p2 ->:"<<*p2<<endl;
    cout<<"p3 ->:"<<*p3<<endl;
    cout<<"p4 ->:"<<*p4<<endl;
    delete p1;//调用C++提供的释放方法来删除对象
    delete_(p3);//调用自己实现的默认的堆的释放方法来删除对象
    //delete_(sys_m,p4);//调用实现的对应的堆释放方法来删除对象
    NullClass *c1=new(NullClass);
    NullClass*c2=new_(NullClass);
    NullClass*c3=alloc(sys_m,NullClass);
    cout<<"default_heap:\n";
    default_heap.char_print(cout);
    cout<<endl;
    default_heap.source_print(cout);
    cout<<"sys_m:\n";
    sys_m.char_print(cout);
    cout<<endl;
    sys_m.source_print(cout);
    //cout<<(*pint).v()<<endl;
    delete(c1);
    //delete_(c2);
    delete_(sys_m,c3);
    //p1使用了引用计数的技术，由Ptr智能指针负责在合适的时间来删除被引用的对象
    cout<<endl;
    char str[]="hello,world!";
    for(int i=0;i<10;i++){
        string *p=new_(string,str,str+(10-i));
        default_heap.char_print(cout);
        delete_(p);
        
    }
    cin.get();
    return 0;
}