En utilisant métaprogrammation modèle pour envelopper des arguments variadique C style

Question

J'ai un Visual Studio 2008 C++ DLL qui exporte une fonction qui accepte un paramètre variadique comme ceci:

__declspec(dllexport) void DLL_Foo(int count, ...) 
{ 
    va_list list; 
    va_start(list, count); 

    for(; count; --count) 
    { 
     const wchar_t* item = va_arg(list, const wchar_t*); 
     if(count % 2 == 0) 
      printfW(L"[%s] ", item); 
     else 
      printfW(L"%s ", item); 
    } 

    va_end(list); 

    printfW(L"\r\n"); 
} 

L'utilisation attendue est quelque chose comme ceci:

DLL_Foo(4, L"int", L"1", L"const wchar_t*", L"Hello"); 

Lorsque la sortie serait:

[int] 1, [const wchar_t*] Hello 

Pour simplifier l'utilisation de cette fonct ion, je l'intention d'inclure une fonction de modèle de C++ comme ceci:

template< class T1, class T2 > 
void Foo(T1 p1, T2 p2) 
{ 
    std::wstringstream t1W; 
    t1W << typeid(p1).name(); 
    std::wstringstream p1W; 
    p1W << p1; 

    std::wstringstream t2W; 
    t2W << typeid(p2).name(); 
    std::wstringstream p2W; 
    p2W << p2; 

    ::DLL_Foo(4, t1W.str().c_str(), p1W.str().c_str(), t2W.str().c_str(), p2W.str().c_str()); 
}; 

Lorsque l'utilisation prévue est comme ceci:

int a = 1; 
const wchar_t* b = L"Hello"; 
Foo(a, b); 

Avec le même résultat escompté comme précédemment.

Existe-t-il une méthode de récurrence de gabarit que je peux utiliser pour ne pas avoir à implémenter une autre fonction template<> Foo() pour les paramètres 0..n?

template<> void Foo(); 
template< class T1 > void Foo(T1 p1); 
template< class T1, ..., class N > void Foo(T1 p1, ..., N n); 

S'il vous plaît, pas de solutions impliquant des modèles variadic ou d'autres fonctionnalités C++ 0x. Je réalise qu'ils sont merveilleux, mais j'utilise VS2008. Aussi, juste pour être plus difficile, je ne peux pas utiliser la fonctionnalité boost comme boost :: MPL.

Merci, PaulH

---

Edit: Oui, la fonction DLL dll réelle ne plus imprimer les informations de type et la valeur. La fonction DLL réelle ressemble un peu plus à ceci:

__declspec(dllexport) void DLL_Foo(MYHANDLE handle, int count, ...) 
{ 
    CMyObject* obj = reinterpret_cast< CMyObject* >(handle); 

    va_list list; 
    for(va_start(list, count); count; --count) 
    { 
     const wchar_t* item = va_arg(list, const wchar_t*); 
     if(count % 2 == 0) 
     { 
      obj->AddTypeInfo(item); 
     } 
     else 
     { 
      obj->AddValueInfo(item); 
     } 
    } 

    va_end(list); 
} 

Answer 1

Ceci est uniquement possible en utilisant les fonctionnalités C++ 0x. Si vous ne pouvez pas utiliser ses modèles variadiques, vous ne pouvez pas créer de fonction ... euh, cela prend un nombre variable de modèles. D'autre part, peut créer plusieurs surcharges de la même méthode, chacune avec son propre nombre d'arguments (1 ... une limite supérieure). C'est bien sûr beaucoup de travail.

Answer 2

La réponse de Konrad est juste.

Cependant, vous pouvez éviter d'écrire les multiples surcharges au prix d'un léger inconvénient pour vos utilisateurs en ayant Foo accepter un tuple, quelque chose comme:

template<class TupleT> 
void Foo(const TupleT& Args) 

Et demander à l'appelant d'envelopper les arguments dans un tuple lorsque vous appelez Foo:

//Foo(an_int, a_bool, a_whatever); 
Foo(boost::make_tuple(an_int, a_bool, a_whatever)); 

... et maintenant, droite comme je suis sur le point de cliquer sur le bouton « postez votre réponse », je vois que vous ne pouvez pas utiliser Boost. Pouvez-vous utiliser le pack de fonctionnalités? Je pense qu'il a std :: tr1 :: tuple.

Answer 3

La dernière fois que j'ai eu besoin de faire quelque chose comme ça, j'ai écrit un script perl qui génèrerait les templates pour moi.Le côté négatif est que vous vous retrouvez avec beaucoup de code à compiler, mais cela dépend de ce que votre max est.