Discussion :

[Invité]

Salut,

est il possible de savoir si tel methode existe dans tel classe en la testant dans une condition ?

merci

[koala01]

Salut,

Non, pas à l'exécution

Par contre, j'ai une bonne nouvelle pour toi : au moment de la compilation, le compilateur va systématiquement refuser l'appel de toute fonction ou fonction membre de classe pour laquelle il n'aura pas trouvé de déclaration compatible.

Mais, pourrais tu nous expliquer ce que tu souhaites faire, car, si tu nous fais ce genre de demande, c'est pour satisfaire un besoin particulier, qu'il serait surement utile de rencontrer.

Ceci dit, j'ai vraiment l'impression qu'il y a un problème de conception là derrière, et qu'il sera nécessaire de repartir de quelque chose de plus sain!

[pyros]

Ca sent le typage dynamique à la javascript ça... Auquel cas c'est une très mauvaise idée de vouloir transposer ce mécanisme au C++, ou à tout autre langage typé statiquement.

[3DArchi]

Salut,

est il possible de savoir si tel methode existe dans tel classe en la testant dans une condition ?

merci

Salut,
A coup de SFINAE on peut faire un peu d'introspection (généralisable à coup de macro et améliorable avec boost.mpl) :

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
template<class T, class Func> struct has_foo_member
{
private:
   struct true_t {};
   struct false_t {true_t t[2];};
 
 
   template<typename T2, Func f> struct has_member;
   template<class T2>
   static true_t test(has_member<T2,&T2::foo_member>*);
   template<class T2>
   static false_t test(...);
public:
   static const bool value = (sizeof(test<T>(0))==sizeof(true_t));
 
};
 
 
struct s1 {};
struct s2 { int foo_member; };
struct s3 { int foo_member(); };
struct s4 { int foo_member() const; };
struct s5 { static int foo_member(); };
 
#include <iostream>
#include <boost\mpl\vector.hpp>
#include <boost\mpl\for_each.hpp>
#include <typeinfo>
 
struct do_test_1
{
   template<class T>
   void operator()(T)const
   {
      std::cout<<typeid(T).name()<<"   "<<has_foo_member<T,int (T::*)()>::value<<"\n";
   }
};
 
struct do_test_2
{
   template<class T>
   void operator()(T)const
   {
      std::cout<<typeid(T).name()<<"   "<<has_foo_member<T,int (T::*)()const>::value<<"\n";
   }
};
 
struct do_test_3
{
   template<class T>
   void operator()(T)const
   {
      std::cout<<typeid(T).name()<<"   "<<has_foo_member<T,int (*)()>::value<<"\n";
   }
};
 
int main()
{
   typedef boost::mpl::vector<s1,s2,s3,s4,s5> types_tests;
   boost::mpl::for_each<types_tests>(do_test_1());
   std::cout<<"\n***\n";
   boost::mpl::for_each<types_tests>(do_test_2());
   std::cout<<"\n***\n";
   boost::mpl::for_each<types_tests>(do_test_3());
   return 0;
}

[Lightness1024]

on appelle ca la reflexion. en C++ il n'y en a pas de manière intrinsèque. tout au plus il y en a de manière statique comme l'indiquent 3DArchi et koala.
au runtime, oui, comme le dit pyros, la reflexion est un classique des langages interpretés comme python ou java.
il est possible de le faire en C++ si y'en a absolument besoin avec des boost::function par exemple. toute methode testable peut etre branchée (avec bind par exemple) dans un foncteur qui peut lui meme etre testé avec .empty().

[3DArchi]

on appelle ca la reflexion. en C++ il n'y en a pas de manière intrinsèque. tout au plus il y en a de manière statique comme l'indiquent 3DArchi et koala.
au runtime, oui, comme le dit pyros, la reflexion est un classique des langages interpretés comme python ou java.
il est possible de le faire en C++ si y'en a absolument besoin avec des boost::function par exemple. toute methode testable peut etre branchée (avec bind par exemple) dans un foncteur qui peut lui meme etre testé avec .empty().

Laurent avait proposé Camp (ici pour l'intro et ici pour la bibliothèque), en revanche, je ne sais pas si elle continue d'être maintenue