Discussion :

[victor_gasgas]

Bonjour,

Est-il possible de détecter si une fonction possède des paramètres par défaut en méta-programmation (je pense notamment à boost::type_traits ou boost::mpl) ?

Merci d'avance!

[oodini]

Ben les traits, c'est pour les classes...

Dans quel contexte aurais-tu besoin de cette info ?

Sinon, à part des tentatives d'instanciation, je ne vois pas...

[Bousk]

Bonjour,

quel serait l'intérêt et que souhaiterais-tu faire réellement ?
Si une méthode attend des arguments et que tu omets d'en passer, tu auras une erreur à la compilation.
A l'inverse si elle a des arguments par défaut, la compilation n'émettra aucune erreur.

Donc,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
void f(int i = 0) { std::cout<<i<<std::endl;}
void g(int i) { std::cout<<i<<std::endl;}
 
int main()
{
 f(); // ok
 f(3); // ok
 g(3); // ok
 g(); // erreur à la compilation
  return 0;
}

[Joel F]

Ben les traits, c'est pour les classes...

Non cf boost::function_traits

Sinon, à part des tentatives d'instanciation, je ne vois pas...

Il faut que la tentative d'instanciation puisse se faire dans un contexte de substitution afin de permettre une deduction de type. Boost.Proto a un is_callable qui fait presque ca, a creuser de ce coté là.

[Emmanuel Deloget]

Bonjour,

Est-il possible de détecter si une fonction possède des paramètres par défaut en méta-programmation (je pense notamment à boost::type_traits ou boost::mpl) ?

Merci d'avance!

Et, non, pas de manière standard. Je ne connais pas non plus d'extension compilateur qui pourrait permettre ça.

La question que je me pose, c'est : qu'est-ce que tu souhaites faire ? Parce que j'ai l'impression que tu oublies une des fonctionnalité de base du C++ : la surcharge de fonctions. Au lieu de créer une fonction prenant 3 paramètres par défauts, tu crées 4 fonctions, chacune avec un paramètre de plus que l'autre, et hop, tu as ta différentiation.

Mais je ne vois toujours pas l'intérêt (et je sens qu'il y en a peu, c'est al raison pour laquelle plus de background serait intéressant : ça nous permettrais de t'expliquer pourquoi tu ne devrais pas faire ce que tu souhaites faire ).

En tout cas, ça sent fort, très fort la premature abstraction.

[oodini]

Non cf boost::function_traits

Boost::function_traits est une structure spécialisée par un pointeur de fonction. Le trait appartient à cette structure, pas à la fonction.

[victor_gasgas]

Désolé de répondre si tardivement mais voici mon contexte:
Je suis en train de faire un interpréteur basé sur http://loulou.developpez.com/tutorie...eur3d/partie7/ mais en c++11.

Pour l'instant voilà comment ça fonctionne:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
std::string MaClasse::csv
(
    const Date &date, 
    const Time &begin, 
    const Time &end
)
{
    // Code de gestion de l'export csv
}
 
// Dans le construteur
std::function<std::string(const Date&, const Time&, const Time&)> csvFunction = std::bind(&MaClasse::csv, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
m_console.registerCommand(csv, csvFunction);

A partir de là dans l'interpréteur, si je tape csv 2-6-2012 10:00:00 12:00:00, alors cela appelle automatiquement la bonne fonction.
Seulement j'aimerais ajouter la gestion de paramètres par défauts, mais là je sèche.

C'est pour cela que j'aurais aimé savoir s'il été possible de détecter les params par défauts, au moins lors de l'extraction des paramètres depuis la chaîne de caractères, je me serais arrété au bon moment.

Même si je pense que là je vais être bloqué plus par une mauvaise conception Si besoin je peux poster plus de code.

Merci beaucoup à tous!


EDIT: Une partie de l'extraction, j'espère que c'est assez compréhensible, au moins le principe général:

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
template<typename FuncType, typename ToDo>
struct ExecuteImpl;
 
 
template<typename FuncType, template<typename...> class ToDo, typename ActualType, typename... ArgsAFaire>
struct ExecuteImpl<FuncType, ToDo<ActualType, ArgsAFaire...>>
{
   template<typename... ArgsDoneType>
    inline static std::string exec(StringExtractor& extractor, const std::function<FuncType> &function, ArgsDoneType... argsDone)
    {
        typename std::remove_const< typename std::remove_reference<ActualType>::type >::type actual;
        extractor >> actual;
 
        return ExecuteImpl<FuncType, ToDo<ArgsAFaire...> >::exec(extractor, function, argsDone..., actual);
    }
};
 
 
template<typename FuncType, template<typename...> class ToDo>
struct ExecuteImpl<FuncType, ToDo<> >
{
    template<typename... ArgsDoneType>
    inline static std::string exec(StringExtractor& extractor, const std::function<FuncType> &function, ArgsDoneType... argsDone)
        {
        extractor.throwIfEOF();
 
        return CallFunction<FuncType, typename std::function<FuncType>::result_type>::Do(function, argsDone...);
    }
};
 
 
// L'appel
template<typename ResultType, typename... ArgsType>
inline std::string ConsoleFunction<ResultType, ArgsType...>::execute
(
    const std::string &params
)
{
    StringExtractor extractor(params);
 
    return priv::ExecuteImpl<ResultType(ArgsType...), ToDo<ArgsType...>>::exec(extractor, m_function);
}

[Joel F]

Boost::function_traits est une structure spécialisée par un pointeur de fonction. Le trait appartient à cette structure, pas à la fonction.

un traits EST une telle structure.