Ulepszenia dla tego przydziału stosu C++?

Question

Wszelkie sugestie dotyczące mojego przydziału na podstawie stosu? (z wyjątkiem sugestie, aby użyć klasy z członków publicznych/prywatnych)

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

Zaimplementowano alokator na podstawie stosu. Nie możesz uwolnić się bez pozostawiania luk. Zwykle pula odnosi się do bloku sąsiadującej pamięci ze szczelinami o ustalonej wielkości, które są podwójnie połączone, aby umożliwić dodawanie i usuwanie stałego czasu.

Here's one możesz użyć jako przewodnika. Jest on zgodny z tymi samymi, co Twój, ale zawiera podstawowe iteratory nad przydzielonymi węzłami i używa szablonów do świadomości typów.

Answer 2

dwa oczywiste problemy:

1/Ty nie masz deallocate().

2/A deallocate() będzie bardzo trudno napisać z twoją obecną strategią, chyba że zawsze będziesz zwolniony w dokładnie odwrotnej kolejności przydziału. Musisz uwzględnić przypadek, w którym klient chce zwolnić pamięć w środku używanej sekcji.

Oczywiście, jeśli zwolnisz zlecenie w odwrotnej kolejności, (2) nie jest to problemem. A jeśli nigdy w ogóle nie uwolnisz pamięci, (1) również nie stanowi to problemu.

To zależy od tego, co chcesz zrobić.

Answer 3

Twoja sterty nie pozwalają na dealokację. W jaki sposób użyjesz go do obiektów przydzielonych z nowy w C++?

Answer 4

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

Niezły, nigdy nie robić takich rzeczy, można zakładać, że sizeof (size_t) == sizeof (void *), także to, co się dzieje, jeśli bytes==(size_t)(-1) to nie będzie działać

Dodatkowo musisz upewnić się, że wskaźniki, które zwracasz, są wyrównane. W przeciwnym razie wystąpiłoby problem. Musisz więc upewnić się, że bajty są wielokrotnością 4 lub 8 według twojej platformy.

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

Propozycja? Nie wymyślaj ponownie koła. Istnieje wiele dobrych bibliotek basenowych.