C++

Metaprogrammation: Comment détecter si une fonction existe ou pas

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Metaprogrammation: Comment détecter si une fonction existe ou pas

papangue

Bonjour,
Dans un code j'aimerai faire le test suivant:

Si la fonction

Code :

template<class T>
stream&<<(stream&,T& )

existe alors je l'utilise, sinon je ne fais rien

Normalement pour ca c'est les traits qu'on utilise. Par contre je n'arrive pas à voir comment (et si c'est possible) de tester la présence d'une fonction sans générer de compile time assertion. J'insiste sur ce dernier point!

Si vous avez une idée?

Merci,

Publicité

Joel F

Real men use unique_ptr

c'est chelou. Faut trouver un cadre dans lequel tu va pouvoir utilisait la SFINAE. Le problème est que, si al fonction existe pas, bah tu pourra guère tenter de l'utiliser sans erreur de compil.
Ca serait une méthode ça aurait pu etre réglé à coup de boost:has_xxx masi en fonction libre

Message cité 1 fois
Message édité par Joel F le 07-03-2008 à 18:19:39

papangue

Joel F a écrit :

Merci pour ta réponse.
C'est exactement juste la réponse qu'il me fallait, compléter avec un peu de google. En utilisant la SFINAE il est possible de checker l'existence de fonctions membres ou même non membre comme dans mon cas.
Merci Joel pour cette info - j'en ai au passage profiter pour apprendre, comprendre ce que l'on pouvait faire avec cette bete.

pour ce qui est de ça:

Citation :

Le problème est que, si al fonction existe pas, bah tu pourra guère tenter de l'utiliser sans erreur de compil.

l'utilisation de la SFINAE permet de checker l'existence d'une méthode (membre ou non membre) sans erreur de compile. Ensuite avec le résultat renvoyer par ce mécanisme, rien ne m'empêche d'écrire une class template avec un paramètre bool, et de specialiser avec: true j'utilise la méthode puisqu'elle existe, false et bien je fait rien!

Juste pour ceux qui veulent des info pour comprendre comment ca marche, j'ai un lien assez sympa:
http://www.codeproject.com/KB/arch [...] etection12

Joel si tu as de la doc un peu plus poussée sur le sujet, je suis preneur!

juste pour illustration, un code test que j'ai écrit pour comprendre:
le fichier .h contenant l'ensemble des class et structure nécessaire à la mise en place de ce petit mécanisme:

Code :

#include <ostream>
class toto
{};
class tata
{};
std::basic_ostream<char>& operator<<(std::basic_ostream<char>& stream, const toto& value)
{
return stream;
}
typedef char NotFound;
struct Found { char x[2]; };
/**
Structure to find functions like std::basic_ostream<char>& std::basic_ostream<char>::operator<<(T)
*/
template <class T, std::basic_ostream<char>& (std::basic_ostream<char>::*)(T) >
struct TestNonStatic_ostream { };
template<class T>
static Found Test_ostream(TestNonStatic_ostream<T,&std::basic_ostream<char>::operator<< >*);
template<class T>
static NotFound Test_ostream( ... );
/**
Structure to find functions like std::basic_ostream<char>& operator<<(std::basic_ostream<char>&, const T& )
*/
template <class T, std::basic_ostream<char>& (*)(std::basic_ostream<char>&,const T& ) >
struct TestNonStatic_operator_ref_const { };
template<class T>
static Found Test_operator_ref_const(TestNonStatic_operator_ref_const<T,&operator<< >*);
template<class T>
static NotFound Test_operator_ref_const( ... );
/**
Structure to find functions like std::basic_ostream<char>& operator<<(std::basic_ostream<char>&, T& )
*/
template <class T, std::basic_ostream<char>& (*)(std::basic_ostream<char>&, T& ) >
struct TestNonStatic_operator_ref { };
template<class T>
static Found Test_operator_ref(TestNonStatic_operator_ref<T,&operator<< >*);
template<class T>
static NotFound Test_operator_ref( ... );
/**
Structure to find functions like std::basic_ostream<char>& operator<<(std::basic_ostream<char>&, T)
*/
template <class T, std::basic_ostream<char>& (*)(std::basic_ostream<char>&, T) >
struct TestNonStatic_operator { };
template<class T>
static Found Test_operator(TestNonStatic_operator<T,&operator<< >*);
template<class T>
static NotFound Test_operator( ... );
template<class T>
struct test
{
static const bool check_presence = (sizeof( Test_ostream<T> ( 0 ) ) == sizeof(Found)) ||
(sizeof( Test_operator_ref_const<T> ( 0 ) ) == sizeof(Found)) ||
(sizeof( Test_operator_ref<T> ( 0 ) ) == sizeof(Found)) ||
(sizeof( Test_operator<T> ( 0 ) ) == sizeof(Found));
};

et maintenant le programme principale:

Code :

int main(/*int argc, _TCHAR* argv[]*/)
{
bool test_ = test<int>::check_presence; // vaut true car la méthode est définit dans la STL
test_ = test<toto>::check_presence; // vaut true car la méthode est définit dans le .h précédent!
test_ = test<tata>::check_presence; // vaut false car pas de méthode définit
return 0;
}

Cdt,

Message cité 1 fois

Joel F

Real men use unique_ptr

papangue a écrit :

Ca m'était sorti de la tête, je cherchais à checker qqchose de plus complexe avec un BOOST_TYPEOF, ta solution est bien meilleur.
L'astuce du type de retour de taille différente et de l'utilisation de l'ellipse pour desambiguer est à la base de 51254289 astuces du mêmes genres d'ailleurs.

papangue a écrit :

Joel si tu as de la doc un peu plus poussée sur le sujet, je suis preneur!

A part une greffe de cerveau, je n'ai rien à te proposer pour l'instant. N'hésite pas à me contacter ultérieurement si tu cherches d'autre infos.

Message édité par Joel F le 09-03-2008 à 20:57:32

papangue

par contre le code que j'ai soumis ci-dessus ne fonctionne pas sous VS2005 avec les type templates:
L'opérateur de flux sortant << est codé comme il se doit, mais est template:

Code :

template<class T>
std::ostream& operator<<(std::ostream& stream, const std::vector<T>& value)
{
// des chose à faire
return stream;
}

mais ce qui est bizarre c'est que
test<std::vector<double> >
me retourne que la fonction n'est pas trouvée.

Et là j'ai du mal à saisir la blague... Bref c'est pas totalement gagné pour le moment.

Pour contourner le probleme je n'ai pas le choix pour le moment de spécifier des tests supplémentaire pour les vectors avec par exemple:

Code :

template <class T, std::basic_ostream<char>& (*)(std::basic_ostream<char>&,const std::vector<T>& ) >
struct TestNonStatic_operator_ref_const_vect { };
template<class T>
static Found Test_operator_ref_const_vect(TestNonStatic_operator_ref_const_vect<typename T::value_type,&operator<< >*);
template<class T>
static NotFound Test_operator_ref_const_vect( ... );

Mais c'est pas très propre.

Déjà si quelqu'un peu m'expliquer pourquoi ca ne marche pas, cela me permettrait peut être de corriger mes erreurs.

Joel F

Real men use unique_ptr

VC++ n'est pas connu pour gérer proprement ce genre d'acrobaties.
Je penche pour une mise en evidence de sa gestion foireuse des spécialisations de templates Rien à faire ...

Message cité 1 fois

papangue

Joel F a écrit :

VC++ n'est pas connu pour gérer proprement ce genre d'acrobaties.
Je penche pour une mise en evidence de sa gestion foireuse des spécialisations de templates Rien à faire ...

Merci pour ta réponse. Ceci explique les abbérations de fonctionnement que je retrouve à travers les tests que j'effectuent sous VC++.

Bien cordialement,

Joel F

Real men use unique_ptr

perso, j'ai arrêté Visual et la méta-prog. Y a toujours un cas foireux qui pète au détour d'un cas particulier. Sans compter que VC++ (enfin WC++) ne supporte que partiellement l'ADL et autre truc complètement indispensable.

FORUM HardWare.fr

Programmation

C++

Metaprogrammation: Comment détecter si une fonction existe ou pas

Sujets relatifs
Debug d'une fonction de validation	EXISTE T IL UNE VERSION DE TURBO PASCAL ?
Créer une fonction en VBA	[Résolu] Problème de variable qui veut pas sortir d'une fonction.
Probleme avec la fonction mysql_connect	synchronized processes : ça existe?
[MySQL] Requète aléatoire en fonction du jour	Comment faire un fichier de fonction
fonction GENERIQUE pour afficher/cacher des DIV	[Access] Filtrer liste déroulante en fonction d'une autre
Plus de sujets relatifs à : Metaprogrammation: Comment détecter si une fonction existe ou pas

Page générée en 0.059 secondes