Jak zrobić zgrupowane lub sparowane złożenie pakietu parametrów?

template<class Msg, class... Args>
std::wstring descf(Msg, Args&&... args) {
    std::wostringstream woss;

    owss << Msg << ". " << ... << " " << args << ": '" << args << "' ";//not legal at all

    //or

    owss << Msg << ". " << args[0] << ": '" << args[1] << "'  " << args[2] << ": '" << args[3] << "' "; //... pseudo code, and so on...
}

Wiem, że zamiast tego mogę po prostu użyć listy par lub czegoś podobnego, ale interesuje mnie to, jak to zrobić, zachowując składnię funkcji w celu:

const auto formatted = descf(L"message", "arg1", arg1, "arg2", arg2);

Możesz użyć wyrażenia krotnie! Nie jest najładniejszy *, ale jest krótszy niż wszystkie przedstawione rozwiązania niepasujące:

template<class T, class ... Args>
std::wstring descf(T msg, Args&&... args) {
    std::wostringstream owss;
    owss << msg << ". ";

    std::array<const char*, 2> tokens{": '", "' "};
    int alternate = 0;
    ((owss << args << tokens[alternate], alternate = 1 - alternate), ...);

    return owss.str();
}

Demo z przykładowym wyjściem: https://godbolt.org/z/Gs8d2x

Wykonujemy fold nad operatorem przecinkowym, gdzie każdy operand jest wyjściem jednego argsi przemiennego tokena, plus przełączanie indeksu tokenu (dwa ostatnie są łączone z innym operatorem przecinkowym).

^{* Dla czytelnika znającego wyrażenia fold (i przecinek) jest to prawdopodobnie „najlepszy” kod, ale dla wszystkich innych jest to kompletny bełkot, więc użyj własnego osądu, czy chcesz nałożyć go na bazę kodu.}

Jest to łatwe dzięki kilku funkcjom pomocniczym, które są zgodne z następującym wzorcem.

void helper() {}

template <class T1, class T2, class ... T>
void helper(T1 t1, T2 t2, T ... t)
{
     do_single_pair(t1, t2);
     helper(t...);
}

To nie jest wyrażenie krotnie, ale wynik netto jest taki sam.

Podejrzewam, że możesz spróbować z indeksem i operatorem trójskładnikowym.

Coś w następujący sposób

template <typename ... Args>
std::wstring descf (std::wstring const & Msg, Args && ... args)
 {
   std::wostringstream woss;

   int i = 0;

   ((woss << Msg << ". "), ... ,(woss << args << (++i & 1 ? ": '" : "' ")));

   return woss.str();
 }

Poniższy kod powinien załatwić sprawę. Pakiet parametrów jest rozwijany na liście inicjalizatora.

#include <string>
#include <iostream>
#include <sstream>
#include <vector>

template <typename...Args>
std::string descf(std::string msg, Args &&... args)
{
   auto argumentsVector = std::vector<std::string>{args...};

   std::stringstream ss;
   ss << msg << ". ";

   for (auto i = std::size_t{0}; i < argumentsVector.size() - 1; ++i)
      ss << argumentsVector[i] << ": '" << argumentsVector[i+1] << "' ";

   auto result = ss.str();
   if (!argumentsVector.empty())
       result.pop_back();
   return result;
}

int main()
{
   std::cout << descf("message", "arg1", "1", "arg2", "2") << std::endl;
}

Z std::index_sequence:

template <class Msg, class... Pairs>
std::wstring descf_pair(const Msg& msg, const Pairs&... pairs)
{
    std::wstringstream woss;

    woss << msg << ". ";
    auto sep = L"";
    ((woss << sep << std::get<0>(pairs) << L": '"
                  << std::get<1>(pairs) << L"'", sep = L"  "), ...);
    return woss.str();
}

template <class Msg, std::size_t... Is, class Tuple>
decltype(auto) descf_impl(const Msg& msg, std::index_sequence<Is...>, Tuple&& t)
{
    return descf_pair(msg, std::tie(std::get<2 * Is>(t), std::get<2 * Is + 1>(t))...);
}

template <class Msg, typename ... Ts>
std::wstring descf(const Msg& msg, const Ts&... ts)
{
    static_assert(sizeof...(Ts) % 2 == 0);

    return descf_impl(msg,
                      std::make_index_sequence<sizeof...(Ts) / 2>(),
                      std::tie(ts...));
}

Próbny