c++ - page - ¿Por qué no hay std:: protect?

latex letter page size

Question

¿Por qué no hay std::protect para usar junto con std::bind en C ++ 11 ?

Boost.Bind proporciona un ayudante boost::protect que envuelve su argumento para que boost::bind no lo reconozca ni lo evalúe. std::[c]ref sería un buen reemplazo la mayoría de las veces, excepto que no tomará un valor de r como valor de argumento.

Para un ejemplo concreto, considere la siguiente situación artificial:

#include <type_traits>
#include <functional>

int add(int a, int b)
{ return a + b; }

struct invoke_with_42
{
    template <typename FunObj>
    auto operator()(FunObj&& fun_obj) const -> decltype((fun_obj(42)))
    { return fun_obj(42); }
};

int main()
{
    //// Nested bind expression evaluated
    //auto bind_expr =
    //    std::bind<int>(invoke_with_42{}
    //      , std::bind(&add, 1, std::placeholders::_1));

    //// Compilation error, cref does not take rvalues
    //auto bind_expr =
    //    std::bind<int>(invoke_with_42{}
    //      , std::cref(std::bind(&add, 1, std::placeholders::_1)));

    //// Ok, inner_bind_expr must be kept alive
    auto inner_bind_expr =
        std::bind(&add, 1, std::placeholders::_1);
    auto outer_bind_expr =
        std::bind<int>(invoke_with_42{}, std::cref(inner_bind_expr));


    //// Ok, with protect
    //auto bind_expr =
    //    std::bind<int>(invoke_with_42{}
    //      , std::protect(std::bind(&add, 1, std::placeholders::_1)));
}

Answer 1

Bueno, no sé por qué no se implementó. Tal vez no fue propuesto, o tal vez hubo algunas trampas sutiles.

Dicho esto, creo que puedes escribirlo bastante fácilmente

template<typename T>
struct protect_wrapper : T
{
    protect_wrapper(const T& t) : T(t)
    {

    }

    protect_wrapper(T&& t) : T(std::move(t))
    {

    }
};

template<typename T>
typename std::enable_if< !std::is_bind_expression< typename std::decay<T>::type >::value,
                T&& >::type
protect(T&& t)
{
    return std::forward<T>(t);
}

template<typename T>
typename std::enable_if< std::is_bind_expression< typename std::decay<T>::type >::value,
                protect_wrapper<typename std::decay<T>::type > >::type
protect(T&& t)
{
    return protect_wrapper<typename std::decay<T>::type >(std::forward<T>(t));
}

Las dos versiones de protect son para que las expresiones no vinculantes no se envuelvan (solo pasan). Todo lo demás se pasa por mover / copiar a protect_wrapper , que simplemente se hereda del tipo. Esto permite que las funciones del tipo pasen a través o que se conviertan al tipo.

Sin embargo, realiza una copia / movimiento, por lo que puede usarse de forma segura con rvals. Y como solo protege los tipos que son bind_expressions, minimiza la cantidad de copias que se deben producir.

int main()
{

    //// Ok, with protect
    auto bind_expr =
        std::bind<int>(invoke_with_42{}
          , protect(std::bind(&add, 1, std::placeholders::_1)));


    std:: cout << bind_expr() << std::endl;
    return 0;

}