Miglioramenti per questo allocatore di stack C++?

Question

Qualche suggerimento per l'allocatore basato sullo stack? (Fatta eccezione per i suggerimenti di utilizzare una classe con membri privati ​​/ pubblici)

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

Hai implementato un allocatore basato su stack. Non puoi liberare senza lasciare spazi vuoti. Di solito un pool fa riferimento a un blocco di memoria contigua con slot di dimensioni fisse, che sono doppiamente collegati per consentire l'aggiunta e l'eliminazione di tempo costante.

Here's one è possibile utilizzare come guida. È sulla stessa linea del tuo ma include iteratori di base sui nodi allocati e utilizza i modelli per essere di tipo type.

Answer 2

Due problemi evidenti:

1/Tu non hai un deallocate().

2/A deallocate() sarà molto difficile scrivere con la strategia corrente, a meno che non si sia sempre in grado di deallocare esattamente nell'ordine inverso di allocazione. Avrai bisogno di soddisfare il caso in cui un cliente vuole deallocare la memoria nel mezzo della sezione utilizzata.

Naturalmente, se si effettua deallocate in ordine inverso, (2) non è un problema. E se non si libera mai memoria, (1) non è un problema.

Dipende da ciò che si desidera che faccia.

Answer 3

L'heap non consente la deallocazione. Come lo userete per oggetti assegnati con new in C++?

Answer 4

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

Non va bene, non fare cose del genere, si assume che sizeof (size_t) == sizeof (void *), anche cosa succede se bytes==(size_t)(-1) questo non avrebbe funzionato

Inoltre, è necessario assicurarsi che i puntatori di ritorno siano allineati. Altrimenti avresti problemi. Quindi è necessario assicurarsi che i byte siano multipli di 4 o 8 in base alla propria piattaforma.

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(); 

Suggerimento? Non reinventare la ruota. Ci sono molte e buone librerie di biliardo.