Framework

[Lolilolight]

Bon je pense que y'a pas moyen de stocker plusieurs fonctions dans un template parameter pack, et de les appeler une à une via l'opérateur ().


Je voudrais aussi vérifier le type de chaque arguments des fonctions, et renvoyer une erreur lors de l'appel de la fonction si le nombre d'arguments ou le type d'un argument est incorrect.

Bref je voudrais faire un peu ce que fait le compilateur..., ainsi, je pourrais lier une action à un ensemble de fonctions qui seront appelée lorsque l'action sera déclenchée.

Pour l'instant j'ai juste créer une classe Function et je pense que je vais faire un std::vector de function et je voudrais lors de l'appel des fonctions ça vérifie si les arguments passé à l'opérateur() correspondent à ceux définis lors de la déclaration des fonctions, pareil si la fonction est appelée sur un objet.

Je pensais stocker la liste des types d'arguments dans un tuple, et les récupérer avec get comme ceci :

std::tuple<ArgsType>... argList;
 

Mais ça ne marche pas, ce code-ci me renvoie une erreur :

Function (Res (*func)(ArgTypes...)) {
        ptr.func = func;
        callback = &call_func;
        argList = ArgTypes; //Erreur.
}
 

PS : un bon compilateur est un compilateur qui nous permet de faire aussi ce que lui fait. 

[Lolilolight]

O_O mais c'est que c'est génial le c++11 !

http://stackoverflow.com/questions/11279044/how-do-i-use-values-from-an-stdtuple-as-function-arguments

[Lolilolight]

Mwai non j'ai parlé trop vite, ça ne marche que pour passer les arguments d'une fonction à un tuple si j'ai bien compris...

Mais pas pour passer les arguments d'un pointeur de fonction...

Donc j'en conclu que y'a pas moyen de le faire. (Car je vois aucune moyen de stocker les arguments d'un pointeurs de fonction dans un tuple...

Bref je pense que je vais faire une classe qui sera un std::vector de Function, et que je vais appeler les fonctions une par une.

Et une autre classe qui connectera les objets et les actions aux fonctions.

Je voulais faire un truc comme std::bind qui créerait automatiquement des Function en lui passant des arguments, qui stockerai les fonctions dans une liste et qui en plus appellerait automatiquement ces fonctions en vérifiant si tout est correct, mais il semblerait que ça ne soit pas possible, tout simplement parce que je ne peux pas récupérer les arguments d'un pointeur de fonction...

[cobra.one]

Passionant... mais euh sans vouloir te vexer t'en es où exactement dans ton projet ? Parce que bon, au bout de 10 pages quasiment à toi tout seul (en exagérant à peine), j'ai du mal à voir exactement ce que tu souhaites obtenir pour une hypothétique première version. Vu de l'extérieur tu donnes l'impression de partir dans tous les sens.

Ne serait-ce pas plus cohérent de figer une "wishlist" de ce que ton projet doit comporter (exit les super nouvelles idées à implémenter tout de suite maintenant avant même que le reste ne soit fonctionnel), ce qui donnerait une idée de son état d'avancement ("fait", "à faire"), et te permettrait de terminer quelque chose de concret.

Fixe toi une liste d'objectifs et essaie de t'y tenir, parce que sinon tu n'auras jamais fini. Et puis celà sert-il à quelque choses de raconter tout ce que tu as fais/fais/voudrais faire pendant des pages et des pages ? Franchement, bosse, fais un truc solide, utilisable, utile et stable, présente-le et puis voilà...

L'idée pouvait paraître bonne, c'est pour ça que je suis ce topic, mais bon là c'est rapidement lassant...

[Laurent]

1) Pourquoi diable veux-tu à tout prix recoder std::function et std::bind ?

2) Tu postes 5 messages par jour, juste pour raconter ce que tu fais, les 3/4 n'étant même pas des questions. Pourquoi n'ouvres-tu pas un blog ? Ca devient un peu chiant là. Surtout que le sujet initial de ce topic, qui ne t'appartient même pas, était tout autre (un framework communautaire, pas ton truc à toi pour lequel tu as déjà moultes topics ouverts).

[Lolilolight]

Salut, non, je veux pas recoder std::function et std::bind, ce que je cherche à faire, c'est, un seul type pour toutes les sortes de fonctions. (Et pas 36 000 types différents comme le font std::bind et std::function)
De plus le mot clé auto ne marche pas en paramètre à une fonction, et encore moins en tant que variable membre.

Bref j'ai réussi à créer tous ces différents types de pointeurs de fonctions dans une seule classe donc ça c'est bon.

Ensuite je vais faire une autre classe qui se chargera de lier les valeurs des arguments des fonctions et un objet si c'est une fonction membre. (Un peu comme le font les signaux et les slots de QT avec une fonction connect.

Bref ça je dois encore le faire mais ça ne m'a pas l'air trop compliqué, donc à la fin ça donnera quelque chose comme ça : (Et je vais en profiter pour terminer en introduisant le système d'event de SFGL qui sera différents de certains autre systèmes.

Les slots :
Les slots de SFGL se crée à l'aide de la classe Function qui peut contenir un pointeur de fonction sur n'importe quel type de fonction, et appeler la fonction via l'opérateur ().

#include <iostream>
#include "myApplication.h"
#include "function.h"
using namespace std;
using namespace sfgl;
class Ex {
    public :

    static void sf() {
        std::cout<<"I'm a static member function!"<<std::endl;
    }
    void of () {
        std::cout<<"I'm an object member function!"<<std::endl;
    }

};
void f (std::string text) {
    std::cout<<"I'm a function "<<text<<endl;
}
int main () {
 Function<void(std::string)> func = &f;
    func("Text");
    Function<void()> staticMemberFunc = &Ex::sf;
    staticMemberFunc();
    Ex obj;
    Function<void(Ex*)> memberFunc = &Ex::of;
    memberFunc(obj);
    return 0;

}
 

J'ai passer les arguments des fonctions à l'opérateur (), mais, ceci n'est pas très pratique , surtout si lors d'une action on a besoin d'appeler la fonction directement à se déclaration.

SFGL possède une classe qui permet de lier les arguments et un objet si c'est une fonction membre à une fonction, cette classe s'appelle la classe signal :

Function<void(std::string)> func = &f;
Signal signal (func, "Text");
 

La classe signal est une sorte de classe bind améliorée qui permettra de contenir n'importe quel type de fonction et d'argument de fonctions à la fois, plus tard, je compte même faire en sorte que Signal permette de créer des "Function" de manière automatique, bref...

Enfin la méthode connect de SFGL permet de connecter une action à un signal :

connect (action, signal);

 

Quand l'action est déclenchée, le signal est appelé, il envoie les arguments au slot pour que le slot puisse appelé le pointeur de fonction.

Bref c'est complètement différent de std::bind qui ne fait que de créer un objets de n'importe quel type (pour cela qu'on doit utiliser le mot clé auto), et donc qui ne me permet pas de stocker mes fonctions pour les appelée plus tard avec une fonction de call back.

[cobra.one]

Je trouve que tu te compliques bien la vie... je dis ça je dis rien...

[Lolilolight]

Pourquoi y'a un moyen plus simple de faire

[cobra.one]

J'ai écris un petit ensemble de classes pour architecturer un projet plaisir sur lequel je travaille à mes heures perdues. Au bout de quelques mois, j'obtiens, en résumant beaucoup, un "framework" proposant un coeur modulaire (insertion/retrait dynamiques de modules, système de communication par appels directs ou bus), et une couche IO, le tout réutilisable pour créer n'importe quel type de jeu.

Et je peux te dire que je suis loin d'être parti dans des trucs super complexes, à vouloir réinventer la roue, avec au final un résultat simple à mettre en oeuvre, stable, et suffisement performant, et surtout qui me permet aujourd'hui de progresser beaucoup plus rapidement dans le développement du "jeu" à proprement parler, et c'est le but.

Et au fait ? Ton système de signaux/slot, n'était-ce pas pour la version 2, comme dis 2/3 pages auparavant ? Il faudrait vraiment que tu songes à finaliser quelque chose de prévu pour la V1 avant d'aller papillonner à droite à gauche, là tu seras crédible. Et aussi, comme dis Laurent, à ouvrir un blog "Moi, Ma Vie, Mon Oeuvre" pour y déverser tes élucubrations...

J'interviens peu sur ce forum, car je trouve dans 99% des cas les réponses à mes questions dans la doc (très bien faite au passage), mais là j'avoue que c'est plus fort que moi. Tu me rappelles une vieille connaissance estudiantine, qui raflait toujours de superbes notes aux soutenances de projets en blablatant sur tout ce qu'il projetait de faire... et qui au final réalisait 1% de ses ambitions initiales...

Bon j'arrête là le hors-sujet...
Ce topic devrait être épinglé "culte", dans la série "Best Of", section "Nid de Coucou" !

[Lolilolight]

Re, hum..., la version 1 n'est pas super pratique..., dans le sens ou il manque pas mal de choses pour rendre le framework vraiment performant, et j'ai besoin d'un système de gui performant pour mon jeux, pour cela que je me consacre à la version 2, la version 1 est finie. (à part remettre un peu d'ordre dans le code et sur les noms de fonctions mais ça, c'est pas ce qui prend le plus de temps)

std::bind est bien mais il ne me permet pas de stocker les arguments d'un pointeur de fonction dans une liste pour l'appeler plus tard comme le font les signaux de Qt, bind sert juste à créer des pointeurs de fonctions, la librairie permettant de faire ce que je veux faire n'existant pas je dois l'implémenter moi même.

J'ai trouvé cependant une solution qui se rapproche du problème. (Le code source manipulant des template pack étant assez compliqué à aborder, car il faut appelle à la récursivité et à la spécialisation de template, j'ai chercher une solution sur internet)

http://stackoverflow.com/questions/7858817/unpacking-a-tuple-to-call-a-matching-function-pointer
 

template<int ...>
    struct seq { };

    template<int N, int ...S>
    struct gens : gens<N-1, N-1, S...> { };

    template<int ...S>
    struct gens<0, S...> {
      typedef seq<S...> type;
    };
    template <typename R> struct Bind {

    };
    template <typename R, typename ...A> struct Bind <R(A...)>  {
        Bind (R(A...), A... args) {
            f = R(A...);
        }
        Function<R(A...)> f
    };
 

Finalement je crois que ça doit être faisable si j'adapte le code source de ce lien à ma structure bind. *-*
Y'a donc rien de bien compliqué là dedans.

Bref je vais arrêter de raconter ma vie sur ce topic. (Ha je serai tellement fier n'en pêche si j'arrive à recoder bind.  )
Et même le système de signaux et de slot de QT.

PS : enfin si il me permet de stocker les paramètre de la fonction, mais pas de stocker la fonction de manière permanente vu que bind, n'est pas une classe.

Et je n'aime pas utiliser la fonction connect de thor que je pense qu'elle permettrait aussi au développeur d'envoyer une simple variable à la fonction connect en call-back => crach. (Enfin, d'après ce que j'ai vu sur son tutoriel)

De plus le système de thor, ne permet pas de passer des arguments d'une fonction (un signal) à une autre fonction (un slot), il faut passer donc par un context sur la renderwindow ce qui complique les chose je trouve.
Moi je n'aurais qu'à faire ceci :

connect (action, objet, Bind<void>(&signal), renderwindow), objet, Bind<void>(&slot));

[/code]

Ou un truc du genre du moins car je n'ai pas encore créer la classe qui connecte tout.

[Lolilolight]

Voilà c'est déjà plus simple comme ça :

template <typename R> struct Bind {

    };
    template <typename R , typename ...A> struct Bind <R(A...)> {
        Bind (R(*f)(A...), A... args) : f(f) {
               params = std::make_tuple(args...);
        }
        Bind (R(*f)(A...)) : f(f) {

        }
        template <int ...S> R operator ()() {

            return f(std::get<0>(params));
        }
        std::tuple<A...> params;
        Function<R(A...)> f;
    };
 

En même temps ça m’entraîne à manipuler les tuples.

Du coup ça me donne ceci (ça ressemble plus à unary function et à binary function en fait mais avec n'importe quel type de fonction et n'importe quel nombre d'arguments)

Bind <void(std::string)> b(&f, "text");
    b();
 

Etant donné que j'ai enfin trouvé la solution à mon problème, je vais arrêter de polluer ce topic qui de plus n'a même pas été créer par moi, et bon, était donné que j'ai déjà fait plusieurs topic sur sfgl je ne sais pas si je devrais en recréer un qui parle mais juste du projet. (Pas d'un proposement de framework communautaire)

PS : plus besoin de s'embêter avec les place holders maintenant. (Par contre pour la déclaration de la fonction entre <> ça, je peux pas faire autrement je pense que je suis obligé de la mettre entièrement (et pas juste préciser le type de retour de la fonction)

Mais si quelqu'un à une solution pour simplifier l'écriture je suis preneur.

Genre comme ça :

Bind <void> b(&f, "text");
    b();
 

Ou alors sans template mais je pense pas que ça soit faisable j'ai essayer ça :

template <> Bind<> {
};
 

Mais mon compilateur ne l'accepte pas.

[Lo-X]

std::bind est bien mais il ne me permet pas de stocker les arguments d'un pointeur de fonction dans une liste pour l'appeler plus tard comme le font les signaux de Qt, bind sert juste à créer des pointeurs de fonctions, la librairie permettant de faire ce que je veux faire n'existant pas je dois l'implémenter moi même.

[...]

Bref je vais arrêter de raconter ma vie sur ce topic. (Ha je serai tellement fier n'en pêche si j'arrive à recoder bind.  )
Et même le système de signaux et de slot de QT.

Les signauxde Qt ne sont pas "programmés" en C++, c'est ajouté à la méta-compilation (c'est pour ça que Qt a une étape en plus  @see moc )

Tu devrais vraiment ouvrir un blog

[Lolilolight]

Les signaux et slots sont un peu lourd à faire avec mon éditeur de map, je dois retaper des commandes à chaque fois que je recrée des signaux et des slots.

Bref avec sfgl les signaux et les slots pourront se créer facilement, sans avoir besoin de faire recours à la méta-compilation, d'ailleurs, les nouveautés du c++11 permettent de faire de la méta-compilation avec les template variadique mais la syntaxe reste compliquée, d'après ce que j'ai pu lire là dessus, cela se réserve à des programmeurs expérimentes.

Bref je vais ouvrir un blog là dessus je pense, en tout cas là j'ai déjà fait 2 classes : une qui stocke des pointeurs de fonctions et une autre qui stocke des pointeurs de fonction  (Function et Bind) et les arguments de fonctions, je dois encore faire 2 classes :

une qui crée des objets de type bind (Classe avec méthodes statiques (la classe Binder)) et une autre qui connecte les actions aux slots crées avec le binder.

Ensuite je fini le deuxième tutoriel de SFGL. (Et je pourrai m'amuser à créer n'importe quel type de gui, et de passer les paramètres des events que je veux aux slots.)

[cobra.one]

Ce topic est une perle ! 

[Lolilolight]

Voilà, je vais inclure bientôt des nouveautés inédites!
Qui permettront de gérer des évènements graphique très rapidement avec sfgl::function et sfgl::bind. (L'un permet de stocker une fonction quelconque (en spécifiant juste sont type de retour), l'autre permet de stocker une fonction et des arguments :

Function<void> ptrf (&f);
ptrf(args1, arg2, ....);
Bind<void>  b (&f, arg1, arg2, ....);
b();
 

Certains pointeurs de fonction seront à définir dans certaines classes comme par exemple la classe ResourceManager pour lui passer la fonction qui se chargera de charger les ressources.

D'autres devront être utilisé pour le système d'évènements avec les interfaces graphiques.

Je compte prévoir aussi un système de placeholders qui pemettra de ne pas devoir spécifier tout les arguments à bind dès la déclaration du pointeur de fonction.