30

grin

31

bon ben en fait ca marche triso
allez juste parceque j'ai envie de te rayer les yeux, jle poste trilove

pour pouvoir ecrire ca: class A { public: A(); int Truc() const; int Truc(int x = 0) const; }; void Tralala() { A a; (a.*GetNaked(&A::Truc))(); // appelle a.Truc() (a.*GetDefault(&A::Truc))(69); // appelle a.Truc(int x) avec x = 69 CallNaked(a, &A::Truc)(); // appelle a.Truc() CallDefault(a, &A::Truc)(69); // appelle a.Truc(int x) avec x = 69 }
#triutile#

faut ca: template<typename _Type, typename _Ret, typename _T0, typename _T1> struct TMethodPointerWrapper { typedef _Ret (_Type::*Signature)(_T0, _T1); _Type *m_Object; Signature m_Method; TMethodPointerWrapper(_Type &object, Signature method) : m_Object(&object), m_Method(method) {} _Ret operator () (_T0 a0, _T1 a1) { return (m_Object->*m_Method)(a0, a1); } }; template<typename _Type, typename _Ret, typename _T0> struct TMethodPointerWrapper<_Type, _Ret, _T0, void> { typedef _Ret (_Type::*Signature)(_T0); _Type *m_Object; Signature m_Method; TMethodPointerWrapper(_Type &object, Signature method) : m_Object(&object), m_Method(method) {} _Ret operator () (_T0 a0) { return (m_Object->*m_Method)(a0); } }; template<typename _Type, typename _Ret> struct TMethodPointerWrapper<_Type, _Ret, void, void> { typedef _Ret (_Type::*Signature)(); _Type *m_Object; Signature m_Method; TMethodPointerWrapper(_Type &object, Signature method) : m_Object(&object), m_Method(method) {} _Ret operator () () { return (m_Object->*m_Method)(); } }; //---------------------------------------------------------------------------- template<typename _Type, typename _Ret, typename _T0, typename _T1> struct TMethodPointerWrapperConst { typedef _Ret (_Type::*Signature)(_T0, _T1) const; const _Type *m_Object; Signature m_Method; TMethodPointerWrapperConst(const _Type &object, Signature method) : m_Object(&object), m_Method(method) {} _Ret operator () (_T0 a0, _T1 a1) { return (m_Object->*m_Method)(a0, a1); } }; template<typename _Type, typename _Ret, typename _T0> struct TMethodPointerWrapperConst<_Type, _Ret, _T0, void> { typedef _Ret (_Type::*Signature)(_T0) const; const _Type *m_Object; Signature m_Method; TMethodPointerWrapperConst(const _Type &object, Signature method) : m_Object(&object), m_Method(method) {} _Ret operator () (_T0 a0) { return (m_Object->*m_Method)(a0); } }; template<typename _Type, typename _Ret> struct TMethodPointerWrapperConst<_Type, _Ret, void, void> { typedef _Ret (_Type::*Signature)() const; const _Type *m_Object; Signature m_Method; TMethodPointerWrapperConst(const _Type &object, Signature method) : m_Object(&object), m_Method(method) {} _Ret operator () () { return (m_Object->*m_Method)(); } }; //---------------------------------------------------------------------------- template<typename _Type, typename _Ret> typename TMethodPointerWrapper<_Type, _Ret, void, void>::Signature GetNaked(_Ret (_Type::*p)()) { return p; } template<typename _Type, typename _Ret, typename _T0> typename TMethodPointerWrapper<_Type, _Ret, _T0, void>::Signature GetDefault(_Ret (_Type::*p)(_T0)) { return p; } template<typename _Type, typename _Ret, typename _T0, typename _T1> typename TMethodPointerWrapper<_Type, _Ret, _T0, _T1>::Signature GetDefault(_Ret (_Type::*p)(_T0, _T1)) { return p; } template<typename _Type, typename _Ret> typename TMethodPointerWrapperConst<_Type, _Ret, void, void>::Signature GetNaked(_Ret (_Type::*p)() const) { return p; } template<typename _Type, typename _Ret, typename _T0> typename TMethodPointerWrapperConst<_Type, _Ret, _T0, void>::Signature GetDefault(_Ret (_Type::*p)(_T0) const) { return p; } template<typename _Type, typename _Ret, typename _T0, typename _T1> typename TMethodPointerWrapperConst<_Type, _Ret, _T0, _T1>::Signature GetDefault(_Ret (_Type::*p)(_T0, _T1) const) { return p; } //---------------------------------------------------------------------------- template<typename _Type, typename _Ret> TMethodPointerWrapper<_Type, _Ret, void, void> CallNaked(_Type &object, _Ret (_Type::*p)()) { return TMethodPointerWrapper<_Type, _Ret, void, void>(object, p); } template<typename _Type, typename _Ret, typename _T0> TMethodPointerWrapper<_Type, _Ret, _T0, void> CallDefault(_Type &object, _Ret (_Type::*p)(_T0)) { return TMethodPointerWrapper<_Type, _Ret, _T0, void>(object, p); } template<typename _Type, typename _Ret, typename _T0, typename _T1> TMethodPointerWrapper<_Type, _Ret, _T0, _T1> CallDefault(_Type &object, _Ret (_Type::*p)(_T0, _T1)) { return TMethodPointerWrapper<_Type, _Ret, _T0, _T1>(object, p); } template<typename _Type, typename _Ret> TMethodPointerWrapperConst<_Type, _Ret, void, void> CallNaked(_Type &object, _Ret (_Type::*p)() const) { return TMethodPointerWrapperConst<_Type, _Ret, void, void>(object, p); } template<typename _Type, typename _Ret, typename _T0> TMethodPointerWrapperConst<_Type, _Ret, _T0, void> CallDefault(_Type &object, _Ret (_Type::*p)(_T0) const) { return TMethodPointerWrapperConst<_Type, _Ret, _T0, void>(object, p); } template<typename _Type, typename _Ret, typename _T0, typename _T1> TMethodPointerWrapperConst<_Type, _Ret, _T0, _T1> CallDefault(_Type &object, _Ret (_Type::*p)(_T0, _T1) const) { return TMethodPointerWrapperConst<_Type, _Ret, _T0, _T1>(object, p); }

#tripropre#
(c'est pour des methodes jusqu'a deux parametres par defaut, pour plus de parametres, faut copier/coller et les rajouter dans les specialisations tritop mais ya surement moyen de rendre ca beaucoup plus compact avec C++11)
par contre, le rendre plus utile, c'est pas dit triso
avatar
HURRRR !

32

bon en fait les CallDefault() ils servent a rien, vu que ca revient a ecrire a.Truc(69)... zzz
avatar
HURRRR !

33

Tu me dois une nouvelle paire d'yeux fatigue
(et en plus la balise code déconne, elle parse les smileys)
avatar
Zeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

34

ouai.. tsss
avatar
HURRRR !

35

Élégant #modpo#




(./32 si, ils participent à la cohérence globale tripo)

36

finalement Get/CallNaked() et Get/CallDefault pourraient etre renommes en un unique RemoveDefaultParameters() tripo
avatar
HURRRR !

37

et appeler directement le pointeur au lieu de faire des casts abominables à base de templates? grin

38

ouai mais la syntaxe pour appeler le pointeur, c'est moche trioui
hem
avatar
HURRRR !

39

Je cherche un bon bouquin pour penser, concevoir objet, en c++ de préférence, vous auriez quelque chose à me proposer svp ? smile
avatar
<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !

40

http://www.manning.com/suereth/

Ça parle pas du tout de C++ mais ça explique comment bien penser et concevoir, en objet et autres.
avatar
« Quand le dernier arbre sera abattu, la dernière rivière empoisonnée, le dernier poisson capturé, alors vous découvrirez que l'argent ne se mange pas. »

41

oh du scala love
So much code to write, so little time.