Perché ho bisogno di std :: get_temporary_buffer?

Per quale scopo dovrei usare std::get_temporary_buffer? Standard dice quanto segue:

Ottiene un puntatore alla memoria sufficiente per memorizzare fino an oggetti T adiacenti.

Ho pensato che il buffer verrà allocato sullo stack, ma non è vero. Secondo lo standard C ++ questo buffer non è in realtà temporaneo. Quali vantaggi ha questa funzione rispetto alla funzione globale ::operator new, che non costruisce nemmeno gli oggetti. Ho ragione che le seguenti affermazioni sono equivalenti?

int* x;
x = std::get_temporary_buffer<int>( 10 ).first;
x = static_cast<int*>( ::operator new( 10*sizeof(int) ) );

Questa funzione esiste solo per la sintassi dello zucchero? Perché c'è temporarynel suo nome?

Un caso d'uso è stato suggerito nel Dr. Dobb's Journal, 1 luglio 1996 per l'implementazione di algoritmi:

Se non è possibile allocare alcun buffer, o se è più piccolo di quanto richiesto, l'algoritmo funziona ancora correttamente, si limita a rallentare.

Stroustrup dice in "The C ++ Programming Language" ( §19.4.4 , SE):

L'idea è che un sistema possa mantenere un numero di buffer di dimensioni fisse pronti per l'allocazione rapida in modo che la richiesta di spazio per n oggetti possa produrre spazio per più di n . Tuttavia, può anche produrre meno, quindi un modo di utilizzare get_temporary_buffer()è chiedere con ottimismo molto e quindi utilizzare ciò che risulta essere disponibile.
[...] Poiché get_temporary_buffer()è di basso livello e può essere ottimizzato per la gestione dei buffer temporanei, non dovrebbe essere utilizzato come alternativa a new o allocator :: allocate () per ottenere una memoria a lungo termine.

Inizia anche l'introduzione alle due funzioni con:

Gli algoritmi richiedono spesso uno spazio temporaneo per funzionare in modo accettabile.

... ma non sembra fornire una definizione di temporaneo oa lungo termine da nessuna parte.

Un aneddoto in "Dalla matematica alla programmazione generica" afferma che Stepanov ha fornito un'implementazione di segnaposto fasulla nel design STL originale, tuttavia:

Con sua sorpresa, ha scoperto anni dopo che tutti i principali fornitori che forniscono implementazioni STL stanno ancora utilizzando questa terribile implementazione [...]

Il ragazzo della libreria standard di Microsoft dice quanto segue ( qui ):

• Potresti forse spiegare quando utilizzare "get_temporary_buffer"

Ha uno scopo molto specializzato. Nota che non genera eccezioni, come new (nothrow), ma non costruisce nemmeno oggetti, a differenza di new (nothrow).

Viene utilizzato internamente dall'STL in algoritmi come stable_partition (). Questo accade quando ci sono parole magiche come N3126 25.3.13 [alg.partitions] / 11: stable_partition () ha complessità "Al massimo (last - first) * log (last - first) swap, ma solo numero lineare di swap se esiste è sufficiente memoria extra. " Quando compaiono le parole magiche "se c'è abbastanza memoria extra", l'STL usa get_temporary_buffer () per tentare di acquisire spazio di lavoro. Se è possibile, può implementare l'algoritmo in modo più efficiente. Se non può, perché il sistema sta funzionando pericolosamente vicino all'esaurimento della memoria (o gli intervalli coinvolti sono enormi), l'algoritmo può ricorrere a una tecnica più lenta.

Il 99,9% degli utenti STL non avrà mai bisogno di sapere di get_temporary_buffer ().

Lo standard dice che alloca lo spazio di archiviazione per un massimo di n elementi. In altre parole, il tuo esempio potrebbe restituire un buffer abbastanza grande solo per 5 oggetti.

Tuttavia, sembra piuttosto difficile immaginare un buon caso d'uso per questo. Forse se stai lavorando su una piattaforma molto limitata dalla memoria, è un modo conveniente per ottenere "quanta più memoria possibile".

Ma su una piattaforma così limitata, immagino che aggireresti il ​​più possibile l'allocatore di memoria e utilizzeresti un pool di memoria o qualcosa su cui hai il pieno controllo.

Per quale scopo dovrei usare std::get_temporary_buffer?

La funzione è deprecata in C ++ 17, quindi la risposta corretta ora è "inutile, non usarla".

ptrdiff_t            request = 12
pair<int*,ptrdiff_t> p       = get_temporary_buffer<int>(request);
int*                 base    = p.first;
ptrdiff_t            respond = p.sencond;
assert( is_valid( base, base + respond ) );

rispondere può essere inferiore alla richiesta .

size_t require = 12;
int*   base    = static_cast<int*>( ::operator new( require*sizeof(int) ) );
assert( is_valid( base, base + require ) );

la dimensione effettiva della base deve essere maggiore o uguale a richiedere .

Forse (solo una supposizione) ha qualcosa a che fare con la frammentazione della memoria. Se continui ad allocare e deallocare pesantemente la memoria temporale, ma ogni volta che lo fai assegni una certa memoria a lungo termine dopo aver allocato il temp ma prima di deallocarlo, potresti finire con un mucchio frammentato (immagino).

Quindi il get_temporary_buffer potrebbe essere inteso come un pezzo di memoria più grande del necessario che viene allocato una volta (forse ci sono molti blocchi pronti per accettare più richieste), e ogni volta che hai bisogno di memoria ne prendi solo uno dei pezzi. Quindi la memoria non viene frammentata.