Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::move_only_function — un wrapper d’appelable déplaçable uniquement

C++23 std::move_only_function stocke un objet appelable avec une signature spécifiée, y compris une lambda qui possède une ressource exclusive. Le wrapper peut être déplacé, mais pas copié. Il doit contenir une cible avant d’être appelé.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#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, déclaré dans <functional> et disponible depuis C++23, est un wrapper à effacement de type : il expose une signature d’appel fixe tout en masquant le type concret stocké. Contrairement à std::function, il n’exige pas une cible copiable ; il peut contenir une lambda qui capture un std::unique_ptr. Le wrapper lui-même ne peut pas être copié.

Le type de signature peut inclure const, un qualificateur de référence & ou &&, ainsi que noexcept. Ces éléments déterminent comment le wrapper peut être appelé et imposent des contraintes à la cible. Par exemple, std::move_only_function<int() && noexcept> exige un wrapper r-value et une cible appelable sans lancer d’exception. Le qualificateur && à lui seul ne garantit pas une utilisation unique.

Un wrapper construit par défaut est vide. Vérifiez if (f) avant l’appel lorsque la présence d’une cible est incertaine : appeler un wrapper vide en C++23 entraîne un comportement indéfini, et non une exception std::bad_function_call garantie. L’affectation de nullptr supprime la cible. Après un déplacement, l’objet source reste valide, mais sa valeur n’est pas spécifiée ; ne supposez pas qu’il est vide.

L’exemple déplace un wrapper contenant une lambda qui possède une ressource, appelle la cible, puis la supprime explicitement. La prise en charge de C++23 est également nécessaire dans la bibliothèque standard ; un indicateur du compilateur ne suffit pas à établir la disponibilité de la fonctionnalité ni l’état de préparation de l’environnement de production. Le code source fourni est un brouillon de travail évolutif, et non un texte C++23 figé.

Exemples

#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';
}

Résultat

42
false

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources