Wie mache ich eine gruppierte oder gepaarte Falte des Parameterpakets?

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...
}

Ich weiß, dass ich stattdessen nur eine Liste von Paaren oder ähnliches verwenden kann, aber ich bin daran interessiert, wie dies zu tun ist, während die Syntax der Funktion wie folgt beibehalten wird:

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

Sie können einen Falzausdruck verwenden! Es ist nicht das schönste *, aber es ist kürzer als alle vorgestellten nicht gefalteten Lösungen:

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 mit Beispielausgabe: https://godbolt.org/z/Gs8d2x

Wir führen eine Faltung über den Kommaoperator durch, wobei jeder Operand eine Ausgabe von einem argsund dem alternierenden Token ist, plus das Umschalten des Tokenindex (die beiden letzteren werden mit einem anderen Kommaoperator kombiniert).

^{* Für einen Leser, der mit Fold-Ausdrücken (und dem Komma-Operator) vertraut ist, ist dies wahrscheinlich der "beste" Code, aber für alle anderen ist es völliger Kauderwelsch. Verwenden Sie also Ihr eigenes Urteil, ob Sie dies Ihrer Codebasis zufügen möchten.}

Dies ist mit einigen Hilfsfunktionen, die dem folgenden Muster folgen, einfach.

void helper() {}

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

Dies ist kein Fold-Ausdruck, aber das Nettoergebnis ist dasselbe.

Ich nehme an, Sie können es mit einem Index und einem ternären Operator versuchen.

Etwas wie folgt

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();
 }

Der folgende Code sollte den Trick machen. Das Parameterpaket wird in einer Initialisierungsliste erweitert.

#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;
}

Mit 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...));
}

Demo