Wie partitioniert und verwendet man Massenspeicher, der en masse mit Rust zugewiesen wurde?

Question

Ich habe in letzter Zeit viel über Rost gelesen, aber ich fange immer noch an zu oxidieren. Mein Gehirn behält die meisten seiner C/C++ - Reflexe, also verzeiht mir, wenn diese Frage nicht relevant ist, weil Dinge in Rust gemacht werden.

Ist es allgemein möglich (wünschenswert?), Einen Block einer willkürlichen Größe auf dem Haufen zuzuordnen und dann eine Datenstruktur darüber mit Bindungen zu bilden, die Besitz von kleineren Stücken des Gedächtnisses übernehmen?

Verwendung von C99 kann man schreiben:

typedef unsigned char BYTE; 

typedef struct { 
    size_t size; 
    BYTE payload[]; 
} flex; 

// ... 

flex * flex_new(size_t _size) { 
    flex *f = malloc(sizeof(flex) + _size * sizeof(BYTE)); 
    f->size = _size; 
    return f; 
} 

Flexible Länge Arrays können als nützlich erweisen, z.B. bei der Implementierung von Speicherpools mit Blöcken variabler Größe oder beim Zuweisen von Speicher auf dem Heap, der einem Thread zugewiesen ist. Die Datenstruktur, deren Größe nur zur Laufzeit bekannt ist, wird atomar zugeordnet und ihre Elemente werden zusammenhängend gepackt.

Ich frage mich, ob eine ähnliche Rust-Implementierung möglich ist (ohne unsafe Konstrukte) und wenn es ist, wie es aussieht. Vielleicht kann der Compiler Informationen unter Verwendung der Lebensdauerspezifizierer in der struct Definition ableiten?

Answer 1

In Bezug auf die ‚flexible Länge Arrays‘ Sie Vec::with_capacity verwenden können mehr als Ihre unmittelbare Notwendigkeit zuzuordnen:

let mut vec: Vec<int> = Vec::with_capacity(10); 

// The vector contains no items, even though it has capacity for more 
assert_eq!(vec.len(), 0); 

// These are all done without reallocating... 
for i in range(0i, 10) { 
    vec.push(i); 
} 

// ...but this may make the vector reallocate 
vec.push(11); 

Für den allgemeineren Fall ist TypedArena was Sie aber verwenden wollen würde.