CKTIS / C++
std::move_only_function — un wrapper di callable spostabile
C++23 std::move_only_function memorizza un oggetto invocabile con una firma specificata, inclusa una lambda che possiede una risorsa esclusiva. Il wrapper si può spostare, ma non copiare. Prima della chiamata deve contenere un target.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <functional>
std::move_only_function<R(Args...)> f;
std::move_only_function<R(Args...) const> cf;
std::move_only_function<R(Args...) &> lf;
std::move_only_function<R(Args...) && noexcept> rf;std::move_only_function, dichiarato in <functional> e disponibile da C++23, è un wrapper con type erasure: espone una firma di chiamata fissa nascondendo il tipo concreto memorizzato. A differenza di std::function, non richiede un target copiabile; può contenere una lambda che cattura uno std::unique_ptr. Il wrapper stesso non può essere copiato.
Il tipo della firma può includere const, un qualificatore di riferimento & o && e noexcept. Questi elementi determinano come si può chiamare il wrapper e impongono vincoli al target. Per esempio, std::move_only_function<int() && noexcept> richiede un wrapper rvalue e un target invocabile senza lanciare eccezioni. Il qualificatore && da solo non garantisce un uso singolo.
Un wrapper costruito per default è vuoto. Controlla if (f) prima della chiamata quando non sai con certezza se è presente un target: chiamare un wrapper vuoto in C++23 causa comportamento indefinito, non un’eccezione std::bad_function_call garantita. Assegnare nullptr rimuove il target. Dopo uno spostamento, l’oggetto sorgente rimane valido, ma ha un valore non specificato; non presumere che sia vuoto.
L’esempio sposta un wrapper contenente una lambda proprietaria di una risorsa, invoca il target e poi lo rimuove esplicitamente. È necessario il supporto a C++23 anche nella libreria standard; una flag del compilatore da sola non dimostra né la disponibilità della funzionalità né la preparazione dell’ambiente di produzione. Il sorgente fornito è una bozza di lavoro in evoluzione, non un testo C++23 immutabile.
Esempi
#include <functional>
#include <iostream>
#include <memory>
#include <utility>
int main() {
std::move_only_function<int(int)> add =
[base = std::make_unique<int>(40)](int x) {
return *base + x;
};
auto task = std::move(add);
if (task) {
std::cout << task(2) << '\n';
}
task = nullptr;
std::cout << std::boolalpha << static_cast<bool>(task) << '\n';
}
Risultato
42 false
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.