Discussion :

[NewbiZ]

Bonjour,

J'aurais voulu savoir s'il existait une méthode pour faire l'inverse d'une fonction avec ellipse.

C'est à dire que j'ai une fonction qui prend en paramètre un nombre variable d'arguments, ces arguments sont récupérés sous forme d'une va_list, et j'aimerais construire un autre appel avec.
En fait, je voudrais un moyen de "faire passer" mes arguments à une autre fonction.

(Prière de ne pas débattre sur le pourquoi mais sur le comment )

Voici le code de la fonction qui recoit les arguments :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template <class IType, class MType>
void Timer<IType, MType>::operator()( float seconds, ... )
{
  // Récupération de la va_list
  (m_instance->*m_method)( /* arguments à placer ici */ );
}

En remerciant ceux qui répondront!

[JolyLoic]

Désolé de te décevoir, mais je vais répondre sur le pourquoi...

En particulier, sais tu que les ... ne te permettent pas de passer des objets autres que des POD ?

En C++, on préfèrera donc aux ... soit le chaînage de fonctions, soit une surcharge avec N paramètres templates (en attendant les variadic templates) :

Chaînage de fonctions :
Exemple typique : on surcharge l'opérateur <<, et f(a, b, c) s'écrit f << a << b << c;

Surcharge de templates :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
template <class C1> operator()(C1 c1);
template <class C1, class C2> operator()(C1 c1, C2 c2);
template <class C1, class C2, class C3> operator()(C1 c1, C2 c2, C3 c3);
template <class C1, class C2, class C3, class C4> operator()(C1 c1, C2 c2, C3 c3, C4 c4);

Il y a des outils dans boost::preprocessor pour générer ce genre de code automatiquement, jusqu'à un nombre fini raisonnable de paramètres.

Dans ces cas, plus de questions à se poser pour transmettre les arguments.

[NewbiZ]

sais tu que les ... ne te permettent pas de passer des objets autres que des POD

Aïe, je l'ignorais en effet.
Donc de toute façon, solution écartée d'office.

J'ai opté pour ta seconde solution, à base de surcharge. Je ne peux pas utiliser boost, mais je l'ai fait à la main (0-7 arguments c'est jouable).
Au final c'est pas très joli mais ca marche, c'est le principal

En te remerciant encore,
Aurélien

[nicroman]

Ca laisse quand même passer des pointeurs !

L'exemple type est quand même le "printf" (bref le formatage).
Et même si les extrémistes du C++ te diront bou c'est pas du C++, il s'avère que dans du logging par exemple, un fprintf est bien plus rapide que toute solution que j'ai pu tenter à base de streams.

Bon... sinon... pour en revenir à ton truc...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void ma_fonction(float seconds, ...)
{
    va_list vargs;
    va_start(vargs,seconds);
    ma_fonction_vargs(seconds,vargs);
    va_end(vargs);
}
 
void ma_fonction_vargs(float seconds, va_list vargs)
{
    utilisation du vargs
}

Pourquoi passer par une fonction intermédiaire ? Pour la réutilisation... Il est impossible d'appeler une fonction à nombre d'arguments variables par une autre... (à moins de le faire en assembleur). Par contre, rien n'empeche la fonction avec un va_list d'appeler une autre fonction à base de va_list...

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
void logit(const char* fmt, ...)
{
    va_list vargs;
    va_start(vargs,fmt);
    logit_vargs(fmt,vargs);
    va_end(vargs);
}
 
void logit_vargs(const char* fmt, va_list vargs)
{
    static char  sbuffer[1027];
    static mutex sbuffer_mutex;
 
    sbuffer_mutex.acquire();
 
    _vsprintf(sbuffer,1024,fmt,vargs);
 
    // OutputDebugStringA(sbuffer);
 
    sbuffer_mutex.release();
}