nach einiger Zeit der C++-Abstinenz möchte ich mich wieder einer richtigen Programmiersprache widmen

Ich habe einen Funktionsaufruf wie (Variable Anzahl von Parametern)

func<3, 1, 4, 2>(param3, param1, param4, param2)

und möchte anhand der Zahlen die Reihenfolge für den eigentlichen Funktionsaufruf sortieren

my_real_func(param1, param2, param3, param4);

Gibt es eine Möglichkeit dies zu verwirklichen? Wer gibt mir den Gedanken Anstoß, den ich brauche?

Hintergrund:

Ich habe eine map<std::string, std::string>, die Attribute aus einem XML-Tag beinhalten.

Anhand dieser Attribute soll Code für einen Funktionsaufruf generiert werden.
Meine Funktion sieht z. B. so aus:

void my_func(const std::string& name,  int value);

In meiner map sind nun die Werte: name->XSpille und value->42
Klar kann ich nicht direkt die Zuordnung zum Variablennamen in der Signatur machen.
Deswegen dachte ich an zusätzliche Konstanten für die Positionen, die aus der inkludierten Datei, in
der sich auch die Funktion befindet kommen:

static const unsigned int attribute_name = 0;
static const unsigned int attribute_value = 1;

Krieg ich es hin, dass ich die Parameter für den Aufruf zur Compilierzeit richtig sortiere?
Ich hab also die Werte für die Parameter und den Namen der Konstante für die Position, wo sie hinsollen:
attribute_name->Spille attribute_value->42
Die Werte, die sich hinter den Konstanten selbst verbergen habe ich zum Zeitpunkt der Codegenerierung nicht,
da ich nicht die komplette inkludierte Datei parsen kann / will.

Gruß
XSpille

#include <tuple>
#include <iostream>

template <typename... T>
void my_real_func(T&&... args)
{
    bool foo[] = { std::cout << args << ' '... };
}

template <int... i, typename... T>
void func(T&&... args)
{
    using tuple_type = std::tuple<T&&...>;
    tuple_type arg_tuple( std::forward<T>( args )... );
    my_real_func( std::forward<typename std::tuple_element<i-1, tuple_type>::type>( std::get<i-1>( arg_tuple ) )... );
}

int main()
{
    func<1, 2, 3>( 2, 3, 5 ); std::cout << '\n';
    func<2, 1, 3>( 2, 3, 5 ); std::cout << '\n';
    func<2, 2, 2>( 2, 3, 5 ); std::cout << '\n';
}

ideone

DANKE Camper

EDIT: Auch wenn es nicht das ist, was ich haben wollte... Die Zahl sollte sagen, an welche Position der Parameter soll, nicht an welcher Parameter an diese Stelle soll... Aber vielleicht kriegt ich es iwie hin

#include <tuple>
#include <iostream>
#include <utility>

template <typename T>
using eval = typename T::type;
template <int i>
using int_ = std::integral_constant<int, i>;

template <typename... T>
void my_real_func(T&&... args)
{
    bool foo[] = { std::cout << args << ' '... };
}

template <int ... i>
struct value_list
{
    using type = value_list;
    static constexpr int size = sizeof...(i);
};

template <int N, typename M = value_list<>>
struct make_value_list;
template <int N, int... i>
struct make_value_list<N,   value_list<i...>>
     : make_value_list<N-1, value_list<0, 1+i...>> {};
template <int... i>
struct make_value_list<0, value_list<i...>>
     : value_list<i...> {};

template <int x, int y>
struct value_pair
{
    friend constexpr int_<y> lookup(int_<x>, value_pair) { return {}; }
    friend constexpr int_<x> reverse_lookup(int_<y>, value_pair) { return {}; }
};

template <typename T, typename U = eval<make_value_list<T::size>>>
struct value_map;
template <int... i, int... j>
struct value_map<value_list<i...>, value_list<j...>>
    : value_pair<i, j>...
{};

template <int... i, typename... T, int... j>
void func_(value_list<j...>, T&&... args)
{
    using tuple_type = std::tuple<T&&...>;
    tuple_type arg_tuple( std::forward<T>( args )... );
    using map_type = value_map<value_list<i...>>;
    my_real_func( std::forward<
         eval<std::tuple_element<decltype(lookup(int_<j+1>{}, map_type{}))::value, tuple_type>>>(
             std::get<decltype(lookup(int_<j+1>{}, map_type{}))::value>( arg_tuple ) )... );
}

template <int... i, typename... T>
void func(T&&... args)
{
    func_<i...>(eval<make_value_list<sizeof...(i)>>(), std::forward<T>( args )... );
}

int main()
{
    func<5, 2, 1, 4, 3>( 10, 20, 30, 40, 50 ); std::cout << '\n';
}

ideone

Ich hatte mir überlegt, es nun über nen Index-Template zu machen.

Ich brauchte 'nur' den richtigen Denkanstoß nachdem ich (zu) lange kein C++ mehr geproggt habe...