Discussion :

[Invité]

Bonjour!

J'ai quelque questions à propos du langages pour savoir si il y a moyen de faire les choses suivantes ou pas.

-Y a t'il moyen d'allouer un pointeur de fonction sur le tas ? Faire quelque chose comme ceci :

Code :

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

void(*func)(int, int, etc...) = new (int args1, int args2, etc...) { //Definition de la fonction ici. }

Je sais qu'il existe les fonctions anonyme mais celles-ci ont un défaut : le compilateur ne peux pas déduire leur type.
Ce qui alourdi la syntaxe dans le cas de l'utilisation d'un wrapper sur la fonction :

Code :

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

wrapper.setParams<std::function<void(int arg1, int arg2, etc...)>> (val1, val2, etc...);

Hors que je n'ai pas besoin de passer de paramètre template pour les fonctions membres et les fonctions non membre, car, le compilateur peut déduire automatiquement le type de la fonction dans ce cas la.

L'avantage du wrapper est que je peux stocker le pointeur de fonction quelque part (dans un tableau par exemple), et changer les paramètres de la fonction n'importe ou dans le programme comme ceci :

Code :

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

wrapper.setParams<std::function<void(int arg1, int arg2, etc...)>, 1, 2> (val1, val2);

Ce qui n'est pas possible avec std::bind et les placeholders.

Seconde question : est-il possible de récupérer la signature d'une fonction membre d'une classe ? (Via le binaire de la classe par exemple)

Ce que je voudrais c'est enregistrer les signatures des fonctions membre d'une classe dans une autre classe automatiquement à la compilation, afin de les appeler à l'exécution, faire un genre de système de réflexion en gros, ceci dans le but de pouvoir appeler des fonctions template virtuelle de la sorte :

Code :

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

baseClass.call(Signature, object, val1, val2, etc...)

Pour l'instant j'enregistre tout ça manuellement dans le main à l'aide de macros mais je voudrais savoir si il n'y a pas moyen de faire un système pour les enregistrer automatiquement.

Voilà merci d'avance pour vos réponses.

Si je demande ça c'est parce que je suis entrain de coder une bibliothèque ici :
http://lolilolightdevblog.wordpress.com/

[Flob90]

Bonjour,

Comment-ça le compilateur ne peut pas déduire le type d'une lambda ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include<iostream>
#include<typeinfo>
 
template<class F>
void foo(F)
{ std::cout << typeid(F).name(); }
 
int main()
{ foo([](){}); }

Fonctionne très bien chez moi.

Pour le second point, dans le binaire c'est assez peu probable. Une fois la compilation faite, il doit rester assez peu d'information sur le typage.

[Invité]

Oui ça marche aussi chez moi si la lambda ne prend pas d'arguments en paramètre.

Mais dès que je veux passer des arguments à la lambda, le compilateur ne peut plus me le déduire donc je dois faire ceci :

Code cpp :

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

1
2
 
wrapper (std::function<void(int)>([](int) {//Définition de la fonction ici!}));

Je dois "convertir" la lambda expression en std::function, en gros lui dire que la lamba expression est une fonction anonyme et pas une lamba4 et quelque chose (je sais pas trop quoi)

Pour le second point cela serait plus compliqué, je ne sais pas si il y a moyen de récupérer des informations sur les fonctions membres en ayant le type de la classe avec le RTTI, ainsi, j'enregistre tout automatiquement dans la factory avec le RTTI et je peux appeler une fonction en lui passant sa signature, sa classe de base et un pointeur sur un objet.

Je sais que en java c'est possible avec les classes Class et Method mais en c++ je ne sais pas.

[Flob90]

Le code que j'ai donné marche tout aussi bien avec [](int){}.

Tu as un exemple simple et complet (que je puisse copier/coller donc) qui me permettrait de voir le problème exacte que tu as avec les lambda ?

[Invité]

Ha non j'ai rien dis ça compile, par contre pour changer la valeur de l'argument de l'expression, je suis obligé de faire ceci :

Code cpp :

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

1
2
3
4
 
 odfaeg::FastDelegate<void> delegate([](int arg) {std::cout<<"arg : "<<arg;}, 1);
 delegate.setFuncParams<std::function<void(int)>>(2);
 delegate();

Sinon, il ne me le déduit pas ici :

Code cpp :

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

1
2
3
4
5
6
 
template <typename F, typename... A> void setFuncParams(A... args) {
        if (static_cast<FastDelegate6<F, A...>*>(delegate)) {
            static_cast<FastDelegate6<F, A...>*>(delegate)->setParams(args...);
        }
    }

Je pense que il n'y a pas moyen d'enregistrer des expressions lambda qui capture des valeurs, cependant ici je peux changer la valeur des paramètres de la lambda expression ou je le veux dans le code car j'ai fais un système de "type erasure" ce que std::bind ne fais pas.
Et j'ai utilisé un tuple pour stocker la valeur des arguments de la fonction et les types des arguments.

Sinon il me semble que c++ ne garde aucune trace sur les définitions des classes dans le binaire comme le fait java. :/

[Flob90]

F ne sera jamais déduit dans cette fonction template car F n'est pas utilisé en paramètre de la fonction. A-tu un exemple d'utilisation de cette fonction avec une lambda qui pose problème ? Tu n'utiliserais pas un decltype sur une expression lambda, du genre decltype([](){}) ? Parce que ça c'est en effet impossible.