Discussion :

[Invité]

Bonjour, ou bonsoir à tous, merci de vous attarder sur mon modeste message

Voila, je voudrais créer une fonction utilisant les template variadiques (parce que je le vaut bien, et que ça me fait bosser) prenant un pointeur sur une fonction en argument, plus les arguments de la fonction en question.

Dans mon exemple (j'ai utilisé un namespace pour pouvoir avoir une utilisation ultérieure) j'ai la fonction chrono, qui renvoie un std::pair<int, typederetour> qui contient le temps d’exécution et la valeur de retour.

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
23
24
25
26
27
28
29
 
//chronoF.h
namespace chronoFonct{
    template<typename Ret, typename... Arg>
    std::pair<int, Ret> chrono(Ret(*fonct)(Arg...), Arg...); // = std::pair<temps, type de retour> chrono(fonction, arguments)
}
//chronoF.cpp
#include "chronoF.h"
 
namespace chronoFonct{
    template<typename Ret, typename... Arg>
    std::pair<int, Ret> chrono(Ret(*fonct)(Arg...), Arg... arguments){
          //...
    }
}
 
//main.cpp
 
#include "chronoF.h"
 
int boucle(bool, char, int){
    for(int i = 0; i < 1000; ++i);
    return 1;
}
 
int main(){
    std::pair<int, int> a = chronoFonct::chrono(boucle, true, 'a', 1);
    return 0;
}

Hors, il y a un os... Voici l'insulte de mon compilo

undefined reference to `std::pair<int, int> chronoFonct::chrono<int, bool, char, int>(int (*)(bool, char, int), bool, char, int)'

voila, je compille avec l'option -std=c++11, et avec mingw

Si vous savez pourquoi cette erreur, vous serez gentil de m'aider...

Merci d'avance

[Bousk]

Bonjour,

les templates doivent être entièrement définis dans des headers et inclus, et jamais dans des fichiers compilés.

[Flob90]

Note au passage que tu pourrais faire plus générique :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
template<class F, class... Arg>
  std::pair<size_t,typename std::result_of<F(Arg...)>::type>
  chrono(F&& f, Arg&&... arg)
{
  //...
  //puis lors de l'appel à f
  using std::forward;
  f(forward<Arg>(arg)...);
  //...
}

(non testé, mais c'est l'idée)

[Invité]

@Flob90 ah ? je comprend pas grand chose à ton code ^^' tu pourrais me l'expliquer s'il te plais ?

En tout cas, merci à tous !

[gbdivers]

L'idée principale est de passer la fonction également en paramètre template. Il utilise en plus le perfect forwarding pour le passage de paramètre (les rvalue refs) (je dois avoir un article encours sur cette technique... un jour peut être il sera publié)

[Invité]

Salut ! Merci pour une réponse aussi rapide !

Je vais me renseigner sur le sujet du perfect forwarding car ça me parait être ma foi un mécanisme fort intéressant ^^

Merci à vous. Je posterai un autre sujet si j'ai des questions.