Discussion :

[Invité]

Salut, je voudrais passer des références à un tuple, faire un genre à ceci :

Code cpp :

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

1
2
 
odfaeg::FastDelegate<void> freeFunction(&bar, std::ref("5"));

Pour la passer ici :

Code cpp :

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

1
2
3
4
 
 template <typename ...A> FastDelegate(void(*f)(A...), A... args) {
        delegate = new FastDelegate0<A...>(f, args...);
    }

Et puis là :

Code cpp :

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

1
2
3
4
5
6
7
 
FastDelegate0 (void(*f)(A...), A... args) {
      typedef void(*CB)(Function<void(A...)>, A... args);
      CB cb = &callback;
      funct = new Functor<void(Function<void(A...)>, A...)> (cb, Function<void(A...)>(f));
      params = std::make_tuple(args...);
}

Mais le compilateur me sors une erreur :

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
 
||=== Build: Debug in ODFAEG-DEMO (compiler: GNU GCC Compiler) ===|
/usr/include/c++/4.8/tuple||In instantiation of ‘constexpr std::_Head_base<_Idx, _Head, false>::_Head_base() [with long unsigned int _Idx = 0ul; _Head = std::reference_wrapper<const char [2]>]’:|
/usr/include/c++/4.8/tuple|251|required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 0ul; _Head = std::reference_wrapper<const char [2]>; _Tail = {}]’|
/usr/include/c++/4.8/tuple|394|required from ‘constexpr std::tuple< <template-parameter-1-1> >::tuple() [with _Elements = {std::reference_wrapper<const char [2]>}]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|69|required from ‘odfaeg::FastDelegate6<F, A>::FastDelegate6(F, A ...) [with F = void (*)(const std::basic_string<char>&); A = {std::reference_wrapper<const char [2]>}]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|435|required from ‘odfaeg::FastDelegate<void>::FastDelegate(F, A ...) [with F = void (*)(const std::basic_string<char>&); A = {std::reference_wrapper<const char [2]>}]’|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|67|required from here|
/usr/include/c++/4.8/tuple|131|error: no matching function for call to ‘std::reference_wrapper<const char [2]>::reference_wrapper()’|
/usr/include/c++/4.8/tuple|131|note: candidates are:|
/usr/include/c++/4.8/functional|445|note: std::reference_wrapper<_Tp>::reference_wrapper(const std::reference_wrapper<_Tp>&) [with _Tp = const char [2]]|
/usr/include/c++/4.8/functional|445|note:   candidate expects 1 argument, 0 provided|
/usr/include/c++/4.8/functional|439|note: std::reference_wrapper<_Tp>::reference_wrapper(_Tp&) [with _Tp = const char [2]]|
/usr/include/c++/4.8/functional|439|note:   candidate expects 1 argument, 0 provided|
/usr/include/c++/4.8/tuple||In instantiation of ‘constexpr std::_Head_base<_Idx, _Head, false>::_Head_base() [with long unsigned int _Idx = 1ul; _Head = std::reference_wrapper<std::basic_string<char> >]’:|
/usr/include/c++/4.8/tuple|251|  recursively required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 1ul; _Head = std::reference_wrapper<std::basic_string<char> >; _Tail = {}]’|
/usr/include/c++/4.8/tuple|251|required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 0ul; _Head = Bar*; _Tail = {std::reference_wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >}]’|
/usr/include/c++/4.8/tuple|527|required from ‘constexpr std::tuple<_T1, _T2>::tuple() [with _T1 = Bar*; _T2 = std::reference_wrapper<std::basic_string<char> >]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|69|required from ‘odfaeg::FastDelegate6<F, A>::FastDelegate6(F, A ...) [with F = void (Bar::*)(const std::basic_string<char>&); A = {Bar*, std::reference_wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >}]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|435|required from ‘odfaeg::FastDelegate<void>::FastDelegate(F, A ...) [with F = void (Bar::*)(const std::basic_string<char>&); A = {Bar*, std::reference_wrapper<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >}]’|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|73|required from here|
/usr/include/c++/4.8/tuple|131|error: no matching function for call to ‘std::reference_wrapper<std::basic_string<char> >::reference_wrapper()’|
/usr/include/c++/4.8/tuple|131|note: candidates are:|
/usr/include/c++/4.8/functional|445|note: std::reference_wrapper<_Tp>::reference_wrapper(const std::reference_wrapper<_Tp>&) [with _Tp = std::basic_string<char>]|
/usr/include/c++/4.8/functional|445|note:   candidate expects 1 argument, 0 provided|
/usr/include/c++/4.8/functional|439|note: std::reference_wrapper<_Tp>::reference_wrapper(_Tp&) [with _Tp = std::basic_string<char>]|
/usr/include/c++/4.8/functional|439|note:   candidate expects 1 argument, 0 provided|
||=== Build failed: 3 error(s), 12 warning(s) (0 minute(s), 3 second(s)) ===|

Donc voila je ne vois pas comment je pourrais passer des références à un tuple.

Merci d'avance pour votre aide.

[stendhal666]

hello,

std::ref("5") ?
Il me semble qu'une référence à un littéral n'a pas trop d'avenir...

Si c'est bien ça ne te sens pas seul, il ne reste pas beaucoup de cerveaux disponibles pour les bases quand on fait de la métaprogrammation à la limite de la lisibilité...
good luck

[ternel]

D'ailleurs, c'est ce que dis le compilateur.

Comment lis-tu ces messages d'erreur?

[Invité]

Je ne voulais pas spécialement parler d'une référence à une litéral, bref...

[jo_link_noir]

D'après le message, j'ai l'impression qu'un reference_wrapper est appeler sans paramètre.
Il faudrait voir comment est fait FastDelegate, mais si pour déterminer le type de retour il y a quelque chose comme decltype(f(A()...), remplace le par decltype(f(std::declval<A>()...)

[Invité]

Salut,

FastDelegate est faîtes comme ça :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 template <typename ...A> FastDelegate(void(*f)(A...), A... args) {
        delegate = new FastDelegate0<A...>(f, args...);
    }
    template <class O, typename ...A> FastDelegate(void(O::*f)(A...), O* object, A... args) {
        delegate = new FastDelegate2<O, A...>(f, object, args...);
 
    }
    template <class O, typename ...A> FastDelegate(void(O::*f)(A...) const, O* object,  A... args) {
        delegate = new FastDelegate2<O, A...>(f, object, args...);
    }
    template <class F, typename ...A> FastDelegate(F f, A... args) {
        delegate = new FastDelegate6<F, A...>(f, args...);
    }

Quand je veux passer une référence il me dit juste ceci :

Code :

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

1
2
 
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|95|error: no matching function for call to ‘odfaeg::FastDelegate<void>::FastDelegate(<unresolved overloaded function type>, Derived*, std::reference_wrapper<odfaeg::OTextArchive>)’|

Sinon pour les pointeurs, pas de problèmes.

[stendhal666]

D'après ton compilateur, il s'agit d'un problème de surcharge de fonction: si tu donnes en argument à ton delegate une fonction surchargée, il ne peut déduire le type de ses arguments (quelle surcharge choisir?). Regarde si cela fonctionne avec une fonction à signature unique.
La solution n'est pas très propre: assigne la surcharge que tu souhaites à un pointeur, et donne le pointeur en argument. Ex:

Code :

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

1
2
3
4
5
6
7
void foo(int, int);
void foo(const char*);
 
fastdelegate(&foo) -> erreur, ambiguité
 
void (*fptr)(int, int) = &foo -> ok
fastdelegate(fptr) -> ok

[Invité]

J'ai réglé le problème de la surcharge en faisant comme ça, cependant, le compilateur ne rentre pas danse cette fonction :

Code cpp :

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

1
2
3
4
5
 
 template <class O, typename ...A> FastDelegate(void(O::*f)(A...), O* object, A... args) {
        delegate = new FastDelegate2<O, A...>(f, object, args...);
 
    }

Mais dans celle-ci :

Code cpp :

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

1
2
3
4
 
template <class F, typename ...A> FastDelegate(F f, A... args) {
        delegate = new FastDelegate6<F, A...>(f, args...);
    }

Ce qui pose problème dans le main :

Code cpp :

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

1
2
3
4
 
odfaeg::OTextArchive oa(of);
    void(Derived::*func)(odfaeg::OTextArchive&) = &Derived::vtserialize;
    odfaeg::FastDelegate<void> delegate (func, new Derived(), oa);

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
 
||=== Build: Debug in ODFAEG-DEMO (compiler: GNU GCC Compiler) ===|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp||In function ‘int main(int, char**)’:|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|91|warning: unused variable ‘wb’ [-Wunused-variable]|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|92|warning: unused variable ‘rb’ [-Wunused-variable]|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|95|warning: unused variable ‘func’ [-Wunused-variable]|
/usr/include/c++/4.9/tuple||In instantiation of ‘constexpr std::_Head_base<_Idx, _Head, false>::_Head_base() [with long unsigned int _Idx = 1ul; _Head = odfaeg::OTextArchive]’:|
/usr/include/c++/4.9/tuple|251|  recursively required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 1ul; _Head = odfaeg::OTextArchive; _Tail = {}]’|
/usr/include/c++/4.9/tuple|251|required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 0ul; _Head = Derived*; _Tail = {odfaeg::OTextArchive}]’|
/usr/include/c++/4.9/tuple|527|required from ‘constexpr std::tuple<_T1, _T2>::tuple() [with _T1 = Derived*; _T2 = odfaeg::OTextArchive]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|121|required from ‘odfaeg::FastDelegate6<F, A>::FastDelegate6(F, A ...) [with F = Bar*; A = {Derived*, odfaeg::OTextArchive}]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|430|required from ‘odfaeg::FastDelegate<void>::FastDelegate(F, A ...) [with F = Bar*; A = {Derived*, odfaeg::OTextArchive}]’|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|96|required from here|
/usr/include/c++/4.9/tuple|131|error: no matching function for call to ‘odfaeg::OTextArchive::OTextArchive()’|
/usr/include/c++/4.9/tuple|131|note: candidates are:|
/usr/local/include/odfaeg/Core/archive.h|61|note: odfaeg::OTextArchive::OTextArchive(std::ostream&)|
/usr/local/include/odfaeg/Core/archive.h|61|note:   candidate expects 1 argument, 0 provided|
/usr/local/include/odfaeg/Core/archive.h|59|note: odfaeg::OTextArchive::OTextArchive(const odfaeg::OTextArchive&)|
/usr/local/include/odfaeg/Core/archive.h|59|note:   candidate expects 1 argument, 0 provided|
/usr/local/include/odfaeg/Core/archive.h|59|note: odfaeg::OTextArchive::OTextArchive(odfaeg::OTextArchive&&)|
/usr/local/include/odfaeg/Core/archive.h|59|note:   candidate expects 1 argument, 0 provided|
||=== Build failed: 2 error(s), 9 warning(s) (0 minute(s), 1 second(s)) ===|

Déjà, pourquoi il ne me retrouve pas le bon constructeur, c'est pourtant bien un pointeur sur fonction membre...

[stendhal666]

Code cpp :

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

1
2
3
4
 
odfaeg::OTextArchive oa(of);
    void(Derived::*func)(odfaeg::OTextArchive&) = &Derived::vtserialize;
    odfaeg::FastDelegate<void> delegate (func, new Derived(), oa);

A quoi correspond le template du FastDelegate (void)?

[Invité]

Au type de retour.

C'est curieux car lorsque je remplace le type de l'argument par OTextArchive*
Ca marche, et je n'ai même pas d'erreur d'overload.

[Flob90]

Personnelement je ne comprends pas pourquoi tu as ouvert une nouvelle discussion et est reparti avec ton code d'origine.

Edit: Référence à http://www.developpez.net/forums/d14...gage-lui-meme/ où on a déjà abordé le code de cette classe et où la problématique pour les passages par référence apparait.

[stendhal666]

Le problème vient je pense du fait que la fonction membre prend une référence comme argument, et que tu donnes au constructeur une valeur. La spécialisation pour les fonctions membres est en conséquence plus bas dans la hiérarchie des correspondances que la version pour les fonctions simples.
Tu devrais essayer de donner au constructeur une référence à la place:

Code :

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

1
2
 
FastDelegate<void> delegate( func, new Derived(), std::ref(oa) );

Par ailleurs si void est le type de retour tu devrais pouvoir le déduire de la fonction que tu lui donnes. Sinon tu perds un peu en élégance et en généralité.

[Invité]

Hum, comment je pourrai déduire le type de retour, j'ai fais deux classes, une pour les fonctions avec type de retour et une pour les fonctions sans type de retour.

Et le deuxième cas. (pour les fonctions sans type de retour est une spécialisation du premier cas qui prend void en type de retour)
typedef void DefaultVoid;
template <> class FastDelegate<DefaultVoid> {
//Blablablah.
};

Si je ne lui spécifie pas que c'est un void il ne me le déduit pas.

J'ai déjà essayé avec un référence wrapper mais ça ne fonctionne pas non plus. :/

Code cpp :

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

1
2
3
4
5
 
std::ofstream ofs("fichierDeSerialisation");
    odfaeg::OTextArchive oa(ofs);
    void(Derived::*func)(odfaeg::OTextArchive) = &Derived::vtserialize;
    odfaeg::FastDelegate<void> delegate(func, new Derived(), std::ref(oa));

Quand je passe par valeur par contre ça marche mais ça ne compile pas car ma classe OTextArchive n'a pas de constructeur par défaut, c'est peut être ça le problème.

Car ma classe OTextArchive prend une référence sur un objet de type ostream.

[stendhal666]

Pour déduire le type de retour de la fonction que tu donnes en argument au constructeur, c'est bien ça?
Dans ce cas, je ferais une classe à part, avec des spécialisations. Qqc comme:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 template <class R, class ...Args>
struct return_type; // si ce n'est pas une fonction, ne compile pas
 
template <class R, class ...Args>
struct return_type<R(*)(...Args)> {
  typedef R type;
};
 
template <class R, class O, class ...Args>
struct return_type<R(0::*)(...Args)> {
  typedef R type;
};

Et ensuite dans ta classe FastDelegate

Code :

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

typedef return_type<F>::type return_type;

//

Dans le nouveau code que tu donnes, tu mets un reference wrapper mais cette fois l'argument de la fonction est par valeur.

[Flob90]

@stendhal666: Presque ca, sauf qu'en faite le type de retour est utilisé dans la classe, donc il est obligé de rester en paramètre :

Code :

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

1
2
3
4
5
6
7
8
 
template<class R>
struct A {
  template<class F>
  A(F&&);
 
  B<R> stuff;
};

Le contournement classique est de faire un make_ :

Code :

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

1
2
3
4
 
template<class F>
auto make_A(F&& f)
{ return A</*stuff to deduce R*/>(std::forward<F>(f)); }

[stendhal666]

@Flob90: très juste, je n'y avais pas pensé.
à moins de faire quelque chose comme:

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
class BIimpl {
  virtual void serialize(std::ostream& os) = 0;
  virtual ~BImpl() {}
  };
 
template <class T>
class DImpl : public BImpl {
  void serialize(std::ostream& os) { /* do stuff */ }
};
 
 
class A {
  public:
  template<class T>
  A(const T& t) {
    impl = new DI<T>();
  }
 
  private:
  BImpl* impl;
};

[Invité]

Ha oui un wrapper sur le type de retour, pourquoi pas. ^^

J'ai mis une référence mais il me recherche toujours un passage par valeur :

Code cpp :

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

1
2
3
 
void(Derived::*func)(odfaeg::OTextArchive&);
odfaeg::FastDelegate<void> del(func, new Derived(), std::ref(oa));

De plus, l'objet dans le tuple est de type std::reference_wrapper<OTextArchive> et non pas de type OTextArchive&.

[stendhal666]

Eh bien...
Il resterait la solution de créer ta référence et de la passer au constructeur:

Code :

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

1
2
3
TextArchive oa(of);
TextArchive& roa = oa;
FastDelegate<void> delegate(func, new Derived(), roa);

Que veux-tu dire par: "il me recherche toujours un passage par valeur" ?

[Invité]

J'ai aussi essayé cette solution mais pour le passage des arguments de la fonctions dans, il me déduis toujours le type OTextArchive et non pas la référence :

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
 
||=== Build: Debug in ODFAEG-DEMO (compiler: GNU GCC Compiler) ===|
/usr/include/c++/4.9/tuple||In instantiation of ‘constexpr std::_Head_base<_Idx, _Head, false>::_Head_base() [with long unsigned int _Idx = 1ul; _Head = odfaeg::OTextArchive]’:|
/usr/include/c++/4.9/tuple|251|  recursively required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 1ul; _Head = odfaeg::OTextArchive; _Tail = {}]’|
/usr/include/c++/4.9/tuple|251|required from ‘constexpr std::_Tuple_impl<_Idx, _Head, _Tail ...>::_Tuple_impl() [with long unsigned int _Idx = 0ul; _Head = Derived*; _Tail = {odfaeg::OTextArchive}]’|
/usr/include/c++/4.9/tuple|527|required from ‘constexpr std::tuple<_T1, _T2>::tuple() [with _T1 = Derived*; _T2 = odfaeg::OTextArchive]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|137|required from ‘odfaeg::FastDelegate6<F, A>::FastDelegate6(F, A ...) [with F = void (Derived::*)(odfaeg::OTextArchive&); A = {Derived*, odfaeg::OTextArchive}]’|
/usr/local/include/odfaeg/Core/fastDelegate.h|446|required from ‘odfaeg::FastDelegate<void>::FastDelegate(F, A ...) [with F = void (Derived::*)(odfaeg::OTextArchive&); A = {Derived*, odfaeg::OTextArchive}]’|
/home/laurent/Développement/Projets-c++/ODFAEG-DEMO/main.cpp|118|required from here|
/usr/include/c++/4.9/tuple|131|error: no matching function for call to ‘odfaeg::OTextArchive::OTextArchive()’|
/usr/include/c++/4.9/tuple|131|note: candidates are:|
/usr/local/include/odfaeg/Core/archive.h|61|note: odfaeg::OTextArchive::OTextArchive(std::ostream&)|
/usr/local/include/odfaeg/Core/archive.h|61|note:   candidate expects 1 argument, 0 provided|
/usr/local/include/odfaeg/Core/archive.h|59|note: odfaeg::OTextArchive::OTextArchive(const odfaeg::OTextArchive&)|
/usr/local/include/odfaeg/Core/archive.h|59|note:   candidate expects 1 argument, 0 provided|
/usr/local/include/odfaeg/Core/archive.h|59|note: odfaeg::OTextArchive::OTextArchive(odfaeg::OTextArchive&&)|
/usr/local/include/odfaeg/Core/archive.h|59|note:   candidate expects 1 argument, 0 provided|
||=== Build failed: 2 error(s), 6 warning(s) (0 minute(s), 1 second(s)) ===|

Ce qui n'est pas bon, A devrait être égal à {Derived*, odfaeg::OTextArchive&} et pas à {Derived*, odfaeg::OTextArchive}, on dirait qu'il me converti automatiquement la référence en valeur lors du passage à ma fonction template.

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template <typename ...A> FastDelegate(void(*f)(A...), A... args) {
        delegate = new FastDelegate0<A...>(f, args...);
    }
    template <class O, typename ...A> FastDelegate(void(O::*f)(A...), O* object, A... args) {
        delegate = new FastDelegate2<O, A...>(f, object, args...);
 
    }
    template <class O, typename ...A> FastDelegate(void(O::*f)(A...) const, O* object,  A... args) {
        delegate = new FastDelegate2<O, A...>(f, object, args...);
    }
    template <class F, typename... A> FastDelegate(F f, A... args) {
        delegate = new FastDelegate6<F, A...>(f, args...);
    }

Je ne sais pas comment le c++ fonctionne avec les template variadique pour la déduction automatique de template, ou alors dois je faire qlqch comme ça ?

Code cpp :

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

1
2
3
4
5
 
 template <class O, typename ...A> FastDelegate(void(O::*f)(A...), O* object, A&&... args) {
        delegate = new FastDelegate2<O, A...>(f, object, args...);
 
    }

[stendhal666]

Oui, tu devrais essayer ça.
Un peu de doc:
http://en.cppreference.com/w/cpp/lan...ment_deduction