Jak przekazać pierwsze args N do C++

Question

funkcją Mam funkcję tak:

void loadData(std::function<void (std::string, std::string, std::string)> callback) 
{ 
    // data loading stuff 
    callback(body, subject, header); 
} 

Problemem jest to, nie jestem koniecznie trzeba używać subject i header w mojej funkcji wywołania zwrotnego. Teraz jestem posługiwaniu się nim w ten sposób:

loadData([](std::string body, std::string, std::string){ 
    std::cout << body; 
}) 

chcę go zastąpić

loadData([](std::string body){ 
    std::cout << body; 
}) 

i automatycznie przejść do funkcji callback jak wiele argumentów, jak to w stanie zaakceptować. Nie chcę ręcznie przeciążać funkcji loadData dla wszystkich 3 możliwych argumentów. Nie chcę również używać bardziej skomplikowanej składni lambda w witrynie wywołującej, ponieważ moja biblioteka powinna być czytelna dla innych użytkowników. Czy jest to możliwe przy użyciu C++ STL i Boost?

Answer 1

mam inspirowane przez jednego z pozostałych odpowiedzi, który zamierza zrobić owijkę, która przechodzi prawidłową liczbę parametrów do funktora. Uważam, że to rozwiązanie jest bardzo przyjemne i pomyślałem, że spróbuję stworzyć szablonową wrapper, w którym liczba argumentów nie jest sztywno zakodowana. Oto co wymyśliłem:

#include <string> 
#include <functional> 
#include <iostream> 

struct WrapperHelp 
{ 
    template 
     < typename L 
     , typename Tuple 
     , std::size_t... Is 
     , typename... Ts 
     > 
    static auto apply(L&& l, Tuple t, std::index_sequence<Is...>, Ts&&... ts) 
     -> decltype(l(std::get<Is>(t)...)) 
    { 
     return l(std::get<Is>(t)...); 
    } 

    template 
     < typename L 
     , typename Tuple 
     , std::size_t... Is 
     , typename T1 
     , typename... Ts 
     > 
    static auto apply(L&& l, Tuple t, std::index_sequence<Is...>, T1&& t1, Ts&&... ts) 
     -> decltype(WrapperHelp::apply(std::forward<L>(l), std::forward_as_tuple(std::get<Is>(t)..., t1), std::make_index_sequence<sizeof...(Is) +1 >(), ts...)) 
    { 
     return WrapperHelp::apply(std::forward<L>(l), std::forward_as_tuple(std::get<Is>(t)..., t1), std::make_index_sequence<sizeof...(Is) + 1>(), ts...); 
    } 
}; 

template<typename L> 
struct OptionalWrapper { 
    public: 
     OptionalWrapper(L l) : lambda{std::move(l)} {} 

     template<typename... Ts> 
     void operator()(Ts&&... ts) const 
     { 
     WrapperHelp::apply(lambda, std::tuple<>(), std::index_sequence<>(), std::forward<Ts>(ts)...); 
     } 

    private: 
     L lambda; 
}; 

template<typename L> 
auto makeOptionalWrapper(L l) { return OptionalWrapper<L>{std::move(l)}; } 

template<class F> 
void loadData(OptionalWrapper<F>&& callback) 
{ 
    std::string body = "body"; 
    std::string subject = "subject"; 
    std::string header = "header"; 
    double lol = 2.0; 
    callback(body, subject, header, lol); 
} 

template<typename L> 
void loadData(L callback) 
{ 
    loadData(makeOptionalWrapper(std::move(callback))); 
} 

int main() { 
    //apply(std::tuple<double>(2), std::tuple<double>(2)); 
    loadData([](auto&& body) { 
     std::cout << body << std::endl; 
    }); 
    loadData([](auto&& body, auto&& subject) { 
     std::cout << body << " " << subject << std::endl; 
    }); 
    loadData([](auto&& body, auto&& subject, auto&& header) { 
     std::cout << body << " " << subject << " " << header << std::endl; 
    }); 
    loadData([](auto&& body, auto&& subject, auto&& header, auto&& lol) { 
     std::cout << body << " " << subject << " " << header << " " << lol << std::endl; 
    }); 
    return 0; 
} 

to powinno działać dla każdej funkcji, z dowolną liczbą parametrów „opcjonalne”, a także z wszelkich typów parametrów. To nie jest najładniejszy kod, ale mam nadzieję, że idea jest jasna i może się przydać :)

Live example

Answer 2

Co z ignorowaniem poniższych argumentów przy użyciu ...?

loadData([](std::string body, ...){ 
    std::cout << body; 
}) 

---

Jak wskazano przez Narratora (dzięki!) Stosowanie elipsy może być nieobsługiwane dla niezarejestrowanych typów trywialne (patrz [expr.call]p9 więcej szczegółów).

Aby uniknąć tego problemu, jeśli możesz używać C++ 14, możesz użyć auto ... (lepiej , aby uniknąć niepotrzebnych kopii, dzięki Yakk).

loadData([](std::string body, auto && ...){ 
    std::cout << body; 
}) 

Answer 3

Można zrobić opakowanie wokół lambda.

template<typename L> 
struct OptionalWrapper { 
    OptionalWrapper(L l) : lambda{std::move(l)} {} 

    void operator()(std::string body, std::string subject, std::string header) const { 
     call(lambda, body, subject, header); 
    } 

private: 
    template<typename T> 
    auto call(T& l, std::string body, std::string subject, std::string header) const 
     -> decltype(l(body, subject, header)) 
    { 
     return l(body, subject, header); 
    } 

    template<typename T> 
    auto call(T& l, std::string body, std::string subject, std::string) const 
     -> decltype(l(body, subject)) 
    { 
     return l(body, subject); 
    } 

    template<typename T> 
    auto call(T& l, std::string body, std::string, std::string) const 
     -> decltype(l(body)) 
    { 
     return l(body); 
    } 

    L lambda; 
}; 

template<typename L> 
auto makeOptionalWrapper(L l) { return OptionalWrapper<L>{std::move(l)}; } 

Następnie użyć otoki tak:

void loadData(std::function<void (std::string, std::string, std::string)> callback) 
{ 
    callback(body, subject, header); 
} 

template<typename L> 
void loadData(L callback) 
{ 
    loadData({makeOptionalWrapper(std::move(callback))}); 
}