Digamos que eu tenha algumas estruturas como esta:

struct MyStruct1 {

    inline void DoSomething() {
        cout << "I'm number one!" << endl;
    }

};

struct MyStruct2 {

    static int DoSomething() {

        cout << "I'm the runner up." << endl;
        return 1;

    }

};

struct MyStruct3 {

    void (*DoSomething)();

    MyStruct3() {
        DoSomething = &InternalFunction;
    }

    static void InternalFunction() {
        cout << "I'm the tricky loser." << endl;
    }

};

omo você pode ver, para todas as três estruturas, eu posso chamar DoSomething () em um objeto dessa estrutura e fazê-la funcionar (embora isso seja alcançado de maneira diferente para cada estrutura

MyStruct1 a;
MyStruct2 b;
MyStruct3 c;

a.DoSomething(); // works, calls Struct1's instance function
b.DoSomething(); // works, calls Struct2's static function, discards return value
c.DoSomething(); // works, calls Struct3's function pointer

gora, digamos que eu coloque uma seleção arbitrária dessas estruturas em uma tupla:

tuple<MyStruct2, MyStruct3, MyStruct2, MyStruct1> collection;

Digamos também que quero pegar um desses elementos e executar seuDoSomething() função baseada em um índice que é determinado em tempo de execução. Para conseguir isso, eu poderia usar uma instrução switch:

switch(index) {

case 0: get<0>(collection).DoSomething(); break;
case 1: get<1>(collection).DoSomething(); break;
case 2: get<2>(collection).DoSomething(); break;
case 3: get<3>(collection).DoSomething(); break;

}

Isso funciona bem e com estilo, mas fica muito tedioso, repetitivo e propenso a erros quando precisa ser feito com várias tuplas organizadas de forma diferente (e potencialmente muito mais longas que quatro elementos). Seria muito útil se uma instrução switch pudesse ser gerada automaticamente com base no número de elementos em um modelo variável. Pseudo-código

template <typename... T>
void DoSomethingByIndex(int index, tuple<T...>& collection) {

    switch(index) {

    STATIC_REPEAT(sizeof...(T), X) {
    case X: get<X>(collection).DoSomething(); break;
    }

    }

}

Existe algum mecanismo no C ++ 11 que me permita conseguir isso? Caso contrário, sei que sem dúvida posso criar uma solução com uma lista de ponteiros de função em um modelo, mas estou curioso para saber se existe algo assim, pois seria mais adequado para meus propósitos. Tenho certeza de que a lista de saltos gerada pelo compilador de uma instrução switch também seria mais eficiente do que minha solução caseira de ponteiro de funçã