Digamos que tengo algunas estructuras 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 puede ver, para las tres estructuras, puedo llamar a DoSomething () en un objeto de esa estructura y hacer que funcione (aunque esto se logra de manera diferente para cada estructura):

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

Ahora, digamos que puse una selección arbitraria de estas estructuras en una tupla:

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

Digamos también que quiero tomar uno de esos elementos y ejecutar suDoSomething() función basada en un índice que se determina en tiempo de ejecución. Para lograr esto, podría usar una declaración de cambio:

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;

}

Esto funciona bien y elegante, pero se vuelve muy tedioso, repetitivo y propenso a errores cuando se debe hacer con múltiples tuplas dispuestas de manera diferente (y potencialmente mucho más largas que 4 elementos). Sería muy útil si una declaración de cambio se pudiera generar automáticamente en función del número de elementos en una plantilla variadic. Pseudocó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 algún mecanismo en C ++ 11 que me permita lograr esto? Si no, sé que, sin duda, puedo hackear una solución con una lista de punteros de función dentro de una plantilla, pero tengo curiosidad por saber si existe algo como esto, ya que sería más adecuado para mis propósitos. Estoy seguro de que la lista de salto generada por el compilador de una declaración de cambio también sería más eficiente que mi solución de puntero de función casera.