Mejoras para este asignador de pila C++?

Question

¿Alguna sugerencia para mi asignador basado en pila? (A excepción de sugerencias para utilizar una clase con miembros privados/públicos)

struct Heap 
{ 
    void* heap_start; 
    void* heap_end; 
    size_t max_end; 

    Heap(size_t size) 
    { 
     heap_start = malloc(size); 
     heap_end = heap_start; 
     max_end = size + (size_t) heap_start; 
    } 

    ~Heap() 
    { 
     ::free(heap_start); 
    } 

    void* allocate(size_t bytes) 
    { 

     size_t new_end = ((size_t) heap_end) + bytes; 

     if(new_end > max_end) 
      throw std::bad_alloc(); 

     void* output = heap_end; 
     heap_end = (void*) new_end; 
     return output; 
    } 

} 

Answer 1

Ha implementado un asignador basado en pila. No puedes liberarte sin dejar huecos. Por lo general, un grupo se refiere a un bloque de memoria contigua con ranuras de tamaño fijo, que están doblemente vinculadas para permitir agregar y eliminar un tiempo constante.

Here's one puede usar como guía. Está en la misma línea que la tuya, pero incluye iteradores básicos sobre nodos asignados, y usa plantillas para escribir.

Answer 2

Dos problemas obvios:

1/Usted no tiene un deallocate().

2/A deallocate() será muy difícil escribir con su estrategia actual a menos que siempre vaya a desasignar en el orden inverso exacto de la asignación. Tendrá que atender el caso en el que un cliente quiere desasignar la memoria en el medio de la sección utilizada.

Por supuesto, si desasigna en orden inverso, (2) no es un problema. Y si nunca liberas memoria, (1) tampoco es un problema.

Depende de lo que quieras que haga.

Answer 3

Su pila no permite la desasignación. ¿Cómo lo usará para los objetos asignados con new en C++?

Answer 4

size_t new_end = ((size_t) heap_end) + bytes; 

No es bueno, no hacer las cosas por el estilo, se asume que sizeof (size_t) == sizeof (void *), también lo que sucede si bytes==(size_t)(-1) esto no funcionaría

Además, necesita asegurarse de que los punteros que devuelve estén alineados. De lo contrario, tendría problemas. Por lo tanto, debe asegurarse de que los bytes sean múltiplos de 4 u 8 según su plataforma.

class {... 
char *max_end,*head_end,*heap_start; 
}; 

... 
max_end=heap_start+size; 
... 
bytes=align_to_platform_specific_value(bytes); 
if(max_end-heap_end >= bytes) { 
    void* output = (void*)heap_end; 
    heap_end+=bytes; 
    return output; 
} 
throw std::bad_alloc(); 

Sugerencia? No reinventes la rueda. Hay muchas y buenas bibliotecas de pool.