boost :: Format ze zmiennej liczbie argumentów argumentów szablonu

Question

Załóżmy, że mam printf -jak funkcji (używane do logowania) wykorzystując idealne do korespondencji:

template<typename... Arguments> 
void awesome_printf(std::string const& fmt, Arguments&&... args) 
{ 
    boost::format f(fmt); 
    f % /* How to specify `args` here? */; 
    BlackBoxLogFunction(boost::str(f).c_str()); 
} 

(nie skompilować tego, ale moje prawdziwe funkcja Wynika to wytyczna)

Jak mogę "rozwinąć" argument zmienny do zmiennej :: :: format zmiennej f?

Answer 1

Jak to zwykle bywa przy zmiennej liczbie argumentów szablonów, można użyć rekurencji:

std::string awesome_printf_helper(boost::format& f){ 
    return boost::str(f); 
} 

template<class T, class... Args> 
std::string awesome_printf_helper(boost::format& f, T&& t, Args&&... args){ 
    return awesome_printf_helper(f % std::forward<T>(t), std::forward<Args>(args)...); 
} 

template<typename... Arguments> 
void awesome_printf(std::string const& fmt, Arguments&&... args) 
{ 
    boost::format f(fmt); 

    auto result = awesome_printf_helper(f, std::forward<Arguments>(args)...); 

    // call BlackBoxLogFunction with result as appropriate, e.g. 
    std::cout << result; 
} 

Demo.

---

W języku C++ 17 wystarczy po prostu (f % ... % std::forward<Arguments>(args));.

Answer 2

Zrobiłem trochę googling i jakieś ciekawe rozwiązanie:

#include <iostream> 
#include <boost/format.hpp> 

template<typename... Arguments> 
void format_vargs(std::string const& fmt, Arguments&&... args) 
{ 
    boost::format f(fmt); 
    int unroll[] {0, (f % std::forward<Arguments>(args), 0)...}; 
    static_cast<void>(unroll); 

    std::cout << boost::str(f); 
} 

int main() 
{ 
    format_vargs("%s %d %d", "Test", 1, 2); 
} 

nie wiem, czy jest to zalecane rozwiązanie, ale wydaje się działać. Nie podoba mi się użycie hacky static_cast, które wydaje się konieczne, aby uciszyć nieużywane ostrzeżenia zmienne w GCC.

Answer 3

Wystarczy podsumować void.pointer's solution i wskazówki proponowane by Praetorian, T.C. i Jarod42, pozwól mi dostarczyć ostateczną wersję (online demo)

#include <boost/format.hpp> 
#include <iostream> 

template<typename... Arguments> 
std::string FormatArgs(const std::string& fmt, const Arguments&... args) 
{ 
    boost::format f(fmt); 
    std::initializer_list<char> {(static_cast<void>(
     f % args 
    ), char{}) ...}; 

    return boost::str(f); 
} 

int main() 
{ 
    std::cout << FormatArgs("no args\n"); // "no args" 
    std::cout << FormatArgs("%s; %s; %s;\n", 123, 4.3, "foo"); // 123; 4.3; foo; 
    std::cout << FormatArgs("%2% %1% %2%\n", 1, 12); // 12 1 12 
} 

Również as it was noted by T.C., używając składni fold expression, dostępny od C++ 17 , funkcja FormatArgs może być przepisana w bardziej zwięzły sposób

template<typename... Arguments> 
std::string FormatArgs(const std::string& fmt, const Arguments&... args) 
{ 
    return boost::str((boost::format(fmt) % ... % args)); 
}