std:: bind_front, std:: bind_back

Les modèles de fonction std::bind_front et std::bind_back génèrent un wrapper d'appel à transfert parfait qui permet d'invoquer la cible appelable avec ses (1,2) premiers ou (3,4) derniers sizeof... ( Args ) paramètres liés à args .

Les conditions suivantes doivent être true , sinon le programme est mal formé :

• (1,3) std:: is_constructible_v < std:: decay_t < F > , F > ,
• (1,3) std:: is_move_constructible_v < std:: decay_t < F >> ,
• (2,4) Si decltype ( ConstFn ) est un pointeur ou un pointeur-vers-membre alors ConstFn n'est pas un pointeur nul,
• ( std:: is_constructible_v < std:: decay_t < Args > , Args > && ... ) ,
• ( std:: is_move_constructible_v < std:: decay_t < Args >> && ... ) .

Paramètres

Valeur de retour

Un objet fonction (le wrapper d'appel) de type T qui n'est pas spécifié, sauf que les types d'objets retournés par deux appels à std::bind_front ou std::bind_back avec les mêmes arguments sont identiques.

Soit bind-partial soit std::bind_front ou std::bind_back .

L'objet retourné possède les propriétés suivantes :

Exceptions

Notes

Ces modèles de fonction sont destinés à remplacer std::bind . Contrairement à std::bind , ils ne prennent pas en charge la réorganisation arbitraire des arguments et n'ont pas de traitement spécial pour les expressions d'encapsulation imbriquées ou les std::reference_wrapper . En revanche, ils tiennent compte de la catégorie de valeur de l'objet wrapper d'appel et propagent la spécification d'exception de l'opérateur d'appel sous-jacent.

Comme décrit dans std::invoke , lors de l'appel d'un pointeur vers une fonction membre non statique ou d'un pointeur vers un membre de données non statique, le premier argument doit être une référence ou un pointeur (incluant, éventuellement, des pointeurs intelligents tels que std::shared_ptr et std::unique_ptr ) vers un objet dont le membre sera accédé.

Les arguments passés à std::bind_front ou std::bind_back sont copiés ou déplacés, et ne sont jamais passés par référence sauf s'ils sont encapsulés dans std::ref ou std::cref .

Typiquement, lier des arguments à une fonction ou à une fonction membre en utilisant ( 1 ) std::bind_front et ( 3 ) std::bind_back nécessite de stocker un pointeur de fonction ainsi que les arguments, même si le langage sait précisément quelle fonction appeler sans avoir besoin de déréférencer le pointeur. Pour garantir un coût nul dans ces cas, C++26 introduit les versions ( 2,4 ) (qui acceptent l'objet appelable comme argument pour paramètre de modèle constant ).

Implémentation possible

namespace detail
{
    template<class T, class U>
    struct copy_const
        : std::conditional<std::is_const_v<T>, U const, U> {};
    template<class T, class U,
             class X = typename copy_const<std::remove_reference_t<T>, U>::type>
    struct copy_value_category
        : std::conditional<std::is_lvalue_reference_v<T&&>, X&, X&&> {};
    template <class T, class U>
    struct type_forward_like
        : copy_value_category<T, std::remove_reference_t<U>> {};
    template <class T, class U>
    using type_forward_like_t = typename type_forward_like<T, U>::type;
}
template<auto ConstFn, class... Args>
constexpr auto bind_front(Args&&... args)
{
    using F = decltype(ConstFn);
    if constexpr (std::is_pointer_v<F> ou std::is_member_pointer_v<F>)
        static_assert(ConstFn != nullptr);
    return
        [... bound_args(std::forward<Args>(args))]<class Self, class... T>
        (
            this Self&&, T&&... call_args
        )
        noexcept
        (
            std::is_nothrow_invocable_v<F,
                detail::type_forward_like_t<Self, std::decay_t<Args>>..., T...>
        )
        -> std::invoke_result_t<F,
                detail::type_forward_like_t<Self, std::decay_t<Args>>..., T...>
        {
            return std::invoke(ConstFn, std::forward_like<Self>(bound_args)...,
                               std::forward<T>(call_args)...);
        };
}

namespace detail { /* est identique à ci-dessus */ }
template<auto ConstFn, class... Args>
constexpr auto bind_back(Args&&... args)
{
    using F = decltype(ConstFn);
    if constexpr (std::is_pointer_v<F> ou std::is_member_pointer_v<F>)
        static_assert(ConstFn != nullptr);
    return
        [... bound_args(std::forward<Args>(args))]<class Self, class... T>
        (
            this Self&&, T&&... call_args
        )
        noexcept
        (
            std::is_nothrow_invocable_v<F,
                detail::type_forward_like_t<Self, T..., std::decay_t<Args>>...>
        )
        -> std::invoke_result_t<F,
                detail::type_forward_like_t<Self, T..., std::decay_t<Args>>...>
        {
            return std::invoke(ConstFn, std::forward<T>(call_args)...,
                               std::forward_like<Self>(bound_args)...);
        };
}

Exemple

#include <cassert>
#include <functional>
int minus(int a, int b)
{
    return a - b;
}
struct S
{
    int val;
    int minus(int arg) const noexcept { return val - arg; }
};
int main()
{
    auto fifty_minus = std::bind_front(minus, 50);
    assert(fifty_minus(3) == 47); // équivalent à : minus(50, 3) == 47
    auto member_minus = std::bind_front(&S::minus, S{50});
    assert(member_minus(3) == 47); // : S tmp{50}; tmp.minus(3) == 47
    // La spécification noexcept est préservée :
    static_assert(!noexcept(fifty_minus(3)));
    static_assert(noexcept(member_minus(3)));
    // Liaison d'une lambda :
    auto plus = [](int a, int b) { return a + b; };
    auto forty_plus = std::bind_front(plus, 40);
    assert(forty_plus(7) == 47); // équivalent à : plus(40, 7) == 47
#if __cpp_lib_bind_front >= 202306L
    auto fifty_minus_cpp26 = std::bind_front<minus>(50);
    assert(fifty_minus_cpp26(3) == 47);
    auto member_minus_cpp26 = std::bind_front<&S::minus>(S{50});
    assert(member_minus_cpp26(3) == 47);
    auto forty_plus_cpp26 = std::bind_front<plus>(40);
    assert(forty_plus(7) == 47);
#endif
#if __cpp_lib_bind_back >= 202202L
    auto madd = [](int a, int b, int c) { return a * b + c; };
    auto mul_plus_seven = std::bind_back(madd, 7);
    assert(mul_plus_seven(4, 10) == 47); // : madd(4, 10, 7) == 47
#endif
#if __cpp_lib_bind_back >= 202306L
    auto mul_plus_seven_cpp26 = std::bind_back<madd>(7);
    assert(mul_plus_seven_cpp26(4, 10) == 47);
#endif
}

Références

Voir aussi