Gestion de l'affectation des vides dans la programmation générique C++

Question

J'ai un code C++ qui enveloppe un lambda arbitraire et renvoie le résultat du lambda.

template <typename F>
auto wrapAndRun(F fn) -> decltype(F()) {
    // foo();
    auto result = fn();
    // bar();
    return result;
}

Cela fonctionne à moins que F renvoie à void ( error: variable has incomplete type 'void' ). J'ai pensé à utiliser un ScopeGuard à exécuter bar mais je ne veux pas bar à exécuter si fn lancés. Des idées ?

P.S. J'ai découvert plus tard qu'il y a une proposition visant à corriger cette incohérence .

Answer 1

Vous pouvez écrire une classe wrapper simple qui gère cette partie :

template <class T>
struct CallAndStore {
    template <class F>
    CallAndStore(F f) : t(f()) {}
    T t;
    T get() { return std::forward<T>(t); }
};

Et se spécialiser :

template <>
struct CallAndStore<void> {
    template <class F>
    CallAndStore(F f) { f(); }
    void get() {}
};

Vous pouvez améliorer la convivialité avec une petite fonction d'usine :

template <typename F>
auto makeCallAndStore(F&& f) -> CallAndStore<decltype(std::declval<F>()())> {
    return {std::forward<F>(f)};
}

Alors, utilisez-la.

template <typename F>
auto wrapAndRun(F fn) {
    // foo();
    auto&& result = makeCallAndStore(std::move(fn));
    // bar();
    return result.get();
}

Edit : avec le std::forward moulage à l'intérieur get Cette méthode semble également gérer correctement le retour d'une référence à partir d'une fonction.

Answer 2

Le nouveau C++17 if constexpr peut être utile ici. Vous pouvez choisir de renvoyer fn() au moment de la compilation :

#include <type_traits>

template <typename F>
auto wrapAndRun(F fn) -> decltype(fn())
{
    if constexpr (std::is_same_v<decltype(fn()), void>)
    {
        foo();
        fn();
        bar();
    }
    else
    {
        foo();
        auto result = fn();
        bar();
        return result;
    }
}

Comme vous l'avez dit, C++2a est également une option, vous pourriez aussi utiliser des concepts, en mettant une contrainte sur la fonction :

template <typename F>
  requires requires (F fn) { { fn() } -> void }
void wrapAndRun(F fn)
{
    foo();
    fn();
    bar();
}

template <typename F>
decltype(auto) wrapAndRun(F fn)
{
    foo();
    auto result = fn();
    bar();
    return result;
}

Answer 3

Vous pouvez jeter un coup d'oeil au ScopeGuard d'Alexandrescu : ScopeGuard.h Il exécute le code uniquement lorsqu'il n'y a pas eu d'exception.

template<class Fn>
decltype(auto) wrapAndRun(Fn&& f) {
  foo();
  SCOPE_SUCCESS{ bar(); }; //Only executed at scope exit when there are no exceptions.
  return std::forward<Fn>(f)();
}

Donc en cas d'absence d'erreur, l'ordre d'exécution est : 1. foo(), 2. f(), 3. bar(). Et en cas d'exception, l'ordre d'exécution est : 1. foo(), 2. f().

Answer 4

Une autre astuce pourrait être d'exploiter l'opérateur virgule, quelque chose comme :

struct or_void {};

template<typename T>
T&& operator,( T&& x, or_void ){ return std::forward<T>(x); }

template <typename F>
auto wrapAndRun(F fn) -> decltype(fn()) {
    // foo();
    auto result = ( fn(), or_void() );
    // bar();
    return decltype(fn())(result);
}

Answer 5

Solution avec SFINAE, l'idée est de faire en sorte qu'une fonction interne void renvoie effectivement int - avec un peu de chance, le compilateur optimisera cela. En extérieur wrapAndRun retournera le même type que la fonction enveloppée.

http://coliru.stacked-crooked.com/a/e84ff8f74b3b6051

#include <iostream>

template <typename F>
auto wrapAndRun1(F fn) -> std::enable_if_t<!std::is_same_v<std::result_of_t<F()>, void>, std::result_of_t<F()>> {
    return fn();
}

template <typename F>
auto wrapAndRun1(F fn) -> std::enable_if_t<std::is_same_v<std::result_of_t<F()>, void>, int> {
    fn();
    return 0;
}

template <typename F>
auto wrapAndRun(F fn) -> std::result_of_t<F()> {
    // foo();
    [[maybe_unused]] auto result = wrapAndRun1(fn);    
    // bar();        
    if constexpr (std::is_void_v<std::result_of_t<F()>>)
        return;
    else
        return result;
}

int main()
{
    wrapAndRun([] { std::cout << "with return \n"; return 0; });
    wrapAndRun([] { std::cout << "no return \n"; });
}