Discussion :

[nixmind]

Bonjour a tous!

Je viens vers vous a cette heure parce que je tante en réaliser quelque chose en C++ depuis hier.
En fait il m'a été donne un projet à réaliser dans lequel je dois commencer par réaliser la notation de la signature d'une fonction à partir d'une structure template.
Pour tout vous dire voici ce que le sujet demande à ce niveau:

Vous devez écrire une structure nommée FunctionSignature, qui prend en template une signature de fonction jusqu’à 4 arguments. Le type devra être accessible à travers le typedef type.
Vous devez vous demander comment faire ?
1. Déclarez une structure qui prend un template ;
2. Déclarez la même structure en spécialisant partiellement la précédente.

La spécialisation aura la forme de la signature de la fonction alors que la partie déclaration de type template déclarera chacun des membres de la signature.

Exemple d'utilisation:
FunctionSignature<int (const std::string& str)>::type f = typeof(onefunction);

J'ai fouille partout sur le net, je n'ai trouve aucune doc ou sujet pouvant m’éclairer. Quelqu'un pense-t-il que c'est vraiment réalisable le truc? Pouvez me donner des idées, ou alors un petit lien utile?

Je vous prie de m'aider a découvrir ce mystère des templates en C++

Merci infiniment pour votre aide.

[nixmind]

Le sujet a été modifie, c'est bien ceci désormais comme exemple :

Code :

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

FunctionSignature<int (const std::string& str)>::type f = &onefunction;

où onefunction est unen function prenant un std::string const et renvoyant un int pour l'exemple.

Mais j'arrive toujours pas a voir comment faire la déclaration et la spécialisation pour gérer la valeur de retour et les paramètres de la fonction dont la signature sera passe en paramètre du template.

Merci.

[kessoufi]

Salut,

tu cherches peut être une classe sous la forme

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
class no_arg
{
};
 
template<
    typename _ret, 
    typename _arg1 = no_arg, 
    typename _arg2 = no_arg, 
    typename _arg3 = no_arg, 
    typename _arg4 = no_arg>
class FunctionSignature
{
public:
    typedef _ret return_type;
    typedef _arg1 arg1_type;
    typedef _arg2 arg2_type;
    typedef _arg3 arg3_type;
    typedef _arg4 arg4_type;
};

avec pour le premier cas :

FunctionSignature<int, const string &>::return_type == int
FunctionSignature<int, const string &>::arg1_type == const string &

tu peux aussi l'exprimer recursivement avec des typelist ( à la façon de boost::tuple/fusion)

Code :

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

1
2
3
4
5
template < typename T, typename U >
struct typelist {
  typedef T element_type;
  typedef U next_type;
};

[nixmind]

Salut A tous!

J'ai pu trouve comment faire mes déclarations et spécialisations finalement.

Merci de m'avoir lu!

[nixmind]

Salut Kessoufi!

J'ai poste sans me rendre compte que tu avais répondu a mon post, puisque ça traînait un peu.

Si non j'avais déjà essaye toutes tes méthodes, mais ça ne marchait pas pour mon projet de metaprog. J'ai finalement réussi a bien le faire.

Je déclare d'abord juste la structure sous forme de forwrad déclaration avec un seul paramètre en template ainsi:

template < typename T>
struct FunctionSignature
{};

et ensuite je fais mes spécialisations en fonction du nombre de paramètres que peut prendre la fonction. C'est ça le trics, du moins celui que j'ai trouve et qui marchent bien.
Avec ça j'ai pu gérer le reste du projet, j'ai applique le même principe pour garder le type d'une variable ou la signature d'une fonction jusqu’à la compilation.

Merci pour ton aide