[templates] petite validation

Version imprimable

Bonjour,

Comme je ne suis pas encore un pro des templates, j’aimerais juste une petite validation de votre part.
j'ai donc fait un template pour autovalider des objets dans une bibliothèque ...
le principe est simple, ils sont enregistré dans une classe Referencies, dans une liste sur leurs interface de base et je peux les instancier

voici mes codes
code des classe exemple

Code:

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
#pragma region CLASS DE BASE
class Base {
public:
    virtual void execute() = 0;
};
class A{
public:
    A(){
        cout << " creation A " << endl;
    }
    ~A(){
        cout << " destruction A " << endl;
    }
    virtual void execute(){
    }
};
 
class B{
public:
    virtual void execute(){
 
    }
};
class C{
};
 
//A a;
//B b;
#pragma endregion

code du template

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//-------------------------------------------------------------------------------
#pragma region REFERENCE ET ADDREFERENCE
 
class baseConstructor {
public:
    virtual void *create() = 0;
};
template<typename Type>
class constructor : public baseConstructor{
public:
    virtual void *create(){
        return new Type();
    }
};
 
/*
Class static de references
*/
template<class Interface>
class Referencies {
private:
    Referencies(){}
public:
    static void Add(string className, baseConstructor *c) {
        if (list == NULL) {
            list = new map<string, baseConstructor *>();
        }
        cout << " Add referencies " << className << endl;
        (*list)[className] = c;
    }
    static vector<string>* getClass(){
        vector<string> *vec = new vector<string>();
        for (map<string, baseConstructor *>::iterator it = list->begin(); it != list->end(); ++it)
            vec->push_back((*it).first);
        return vec;
    }
    static Interface* newInstance(string s){
        try{
            Interface* i = (Interface*)(*list)[s]->create();
            return i;
        }
        catch (...){
            return NULL;
        }
    }
private:
    static map<string, baseConstructor *> *list;
};
/* membre static de Referencies */
template<class Interface>
map<string, baseConstructor *> *Referencies<Interface>::list = NULL;
 
template<class Interface, class Type>
class AddReferency {
public:
    AddReferency(){
        cout << "[AddReferency] create " << endl;
        Referencies<Interface>::Add(type_name<Type>(), new constructor<Type>());
    }
    ~AddReferency(){
        cout << "[AddReferency] delete " << endl;
    }
};
#pragma endregion

code d’utilisation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
// usage en static
AddReferency<Base, A> insert;
AddReferency<Base, B> insert1;
 
AddReferency<B, A> insert2;
 
// utilisation
show(Referencies<Base>::getClass());
cout << "referebnce sur bn " << endl;
show(Referencies<B>::getClass());
 
Base *b = Referencies<Base>::newInstance("A");

code d'utilitaires

Code:

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
// code pour remplacer le typeid(T).name()
std::string replace(std::string base, const std::string from, const std::string to) {
    std::string SecureCopy = base;
    for (size_t start_pos = SecureCopy.find(from); start_pos != std::string::npos; start_pos = SecureCopy.find(from, start_pos))
    {
        SecureCopy.replace(start_pos, from.length(), to);
    }
    return SecureCopy;
}
 
bool my_predicate(char c) {
    return (c >= 0x30 && c < 0x39);
}
#include <algorithm> 
template<typename T>
string type_name(){
    string s = string(typeid(T).name());
    // for visual c++
    s = replace(s, string("class"), string(""));
    s = replace(s, string(" "), string(""));
    // for gcc
    s.erase(std::remove_if(s.begin(), s.end(), my_predicate), s.end());
    cout << s << endl;
    return s;
}
// visualisation des entrées
void show(vector<string> *list){
    cout << endl << "LIST " << endl;
    for (vector<string>::iterator it = list->begin(); it != list->end(); ++it) {
        cout << " -" << (*it) << endl;
    }
}

voila vous pouvez commenter mon code, si on peut l’écrire mieux notamment au niveau du constructeur constructor etc...

18/09/2014, 09h51
Médinoc

Je pense qu'une des premières choses à faire est de rendre ta classe de base explicitement non-copiable.
À quelle version du standard C++ as-tu accès?

Salut,

j'ai pas compris l'utilité de ton truc ? :calim2:

Tes classes Base, A, B etc n'ont aucune relation entre elle, et tu sembles vouloir les utiliser "comme héritage" ? :weird:

Tu fais un cast barbare vers Interface* (donc Base*) d'un new A qui n'a strictement rien à voir avec Base. :weird:

Et surtout, ce qui m'a juste choqué :
Code:

1 2 3 4 5 6 static vector<string>* getClass(){ vector<string> *vec = new vector<string>(); for (map<string, baseConstructor *>::iterator it = list->begin(); it != list->end(); ++it) vec->push_back((*it).first); return vec; }
8O8O8O

Et list n'a aucune raison valable d'être un pointeur.

18/09/2014, 10h22
ikeas

l'utilité c'est de référencer automatiquement les classes utils d'une shared library au chargement de celle ci
il faut savoir que celui qui charge la shared library ne sait pas au départ quels sont les objets qui se trouve dedans
il pourra juste les instancier sous la forme de leur interface
c'est une sorte d'utilisation de plugs-ins

c'est vrai qu'on peut utiliser la liste (vector<string>) sans pointeur

pour A je vais vérifier qu'il dérive bien de Base a la construction du template
je l'ai juste pas encore fait dans le template
j'ai pas trouvé de solution acceptable pour typer directement dans le new avec le constructeur

Citation:

Envoyé par Médinoc

Je pense qu'une des premières choses à faire est de rendre ta classe de base explicitement non-copiable.
À quelle version du standard C++ as-tu accès?

je n'ai pas acces a c++11
je suis

g++ (GCC) 4.4.6 20120305 (Red Hat 4.4.6-4)
Copyright (C) 2010 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

et je ne peux hélas pas changer

Ca ressemble fort à ce que j'essaye de faire.

Code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
//fichier fabrique.h
#ifndef ODFAEG_FACTORY_HPP
#define ODFAEG_FACTORY_HPP
#include <map>
#include <string>
#include "export.hpp"
#include "fastDelegate.h"
/**\file factory.h
*  \brief This file register types of derived objects
*  and instanciate the polymorphic objects of the right type with the given type id.
*  There are two factories
*  The static factory (The class Factory) which evaluate objects and functions at compile time.
*  The dynamic factory (The class BaseFactory) which evaluate objects and functions at runtime.
*  The dynamic factory avoids to have a reflexion system which is impossible to make in c++ without a lot of macros.
*  \author Duroisin.L
*  \version 1.0
*  \date 1/02/2014
*/
/********************************************************************************************************************/
/**\fn
* \brief This is an helper function like macro which register a derived type in the dynamic factory.
* \param ID : an ID which is associate to a derived type.
* \param BASE : the base type of the derived class.
* \param DERIVED : the derived type of the derived class.
*/
#define REGISTER_TYPE(ID, BASE, DERIVED) \
{ \
DERIVED *derived##ID = nullptr; \
odfaeg::Allocator<BASE> allocator##ID; \
BASE*(odfaeg::Allocator<BASE>::*f##ID)(DERIVED*) = &odfaeg::Allocator<BASE>::allocate<DERIVED>; \
odfaeg::FastDelegate<BASE*> allocatorDelegate##ID(f##ID, &allocator##ID, derived##ID); \
odfaeg::BaseFact<BASE>::register_type(typeid(DERIVED).name(), allocatorDelegate##ID); \
}
/**fn
* \brief This is an helper function like macro which register a function in the dynamic factory.
* \param ID : an ID which is associate to a derived type.
* \param funcName : the name of the derived class member's function to register.
* \param SID : an ID associated to the argument list of the member's function to register.
* \param BASE : the base type of the derived class.
* \param DERIVED : the derived type of the derived class.
* \param SIGNATURE : the signature of the function to register.
*/
#define REGISTER_FUNC(ID, funcName, SID, BASE, DERIVED, SIGNATURE, args...) \
{ \
REGISTER_TYPE(ID, BASE, DERIVED) \
void(DERIVED::*f##ID##funcName##SID)SIGNATURE = &DERIVED::vt##funcName; \
odfaeg::FastDelegate<void> delegate##ID##funcName##SID (f##ID##funcName##SID, args); \
odfaeg::BaseFact<BASE>::register_function(typeid(DERIVED).name(), #funcName, #SID, delegate##ID##funcName##SID); \
}
/**
  *\namespace odfaeg
  * the namespace of the Opensource Development Framework Adapted for Every Games.
  */
namespace odfaeg {
/**\class Allocator
*  \brief this struct allocate an object of a derived type and return a pointer of the base type.
*  \param B : the base type.
*/
template <typename B>
struct Allocator {
   /**\fn allocate(D*)
   *  \brief this function allocates an object of a derived type and return a pointer of the base type.
   *  \param D : the derived type.
   *  \return B* : a pointer to the base type.
   */
   template <typename D>
   B* allocate(D*) {
        return new D();
   }
};
/**\class BaseFactory
*  \brief This class register types of derived objects
*  and instanciate the polymorphic objects of the right type with the given type id.
*  This is a dynamic factory, it means that the id is defined at runtime time with RTTI infos.
*  So you must provide the id with typeid(object).name().
*  \author Duroisin.L
*  \version 1.0
*  \date 1/02/2014
*/
template <typename B>
class BaseFactory {
    public :
    /**
    * \fn void register_type (std::string typeName, FastDelegate<B*> allocatorDelegate)
    * \brief register a type into a factory, if the type isn't already registered.
    * \param std::string typeName : the name of the type to register.
    * \param a callback function to an allocator, to return a pointer of the base class which point
    * to the derived object.
    */
    static void register_type(std::string typeName, FastDelegate<B*> allocatorDelegate) {
        typename std::map<std::string, FastDelegate<B*>>::iterator it = types.find(typeName);
        if (it == types.end()) {
            types[typeName] = allocatorDelegate;
        }
    }
    /** \fn void register_function(std::string typeName, std::string funcName, std::string funcArgs, FastDelegate<void> delegate)
    *   \brief register a member function of a class type into the factory.
    *   \param std::string typeName : the type name of the class containing the member function to register.
    *   \param std::string funcName : the name of the function to register.
    *   \param std::string funcArgs : the name of the types of the member function's argument list to register.
    *   \param FastDelegate<void> delegate : a callback function of the registered member function. (only funcions returing void can be registered!)
    */
    static void register_function(std::string typeName, std::string funcName, std::string funcArgs, FastDelegate<void> delegate) {
        typename std::map<std::string, FastDelegate<void>>::iterator it = functions.find(typeName+funcName+funcArgs);
        if (it == functions.end())
            functions[typeName+funcName+funcArgs] = delegate;
    }
    /** \fn void callFunction(std::string typeName, std::string funcName, std:string fincArgs, A&&... args)
    *   \brief call a registered function of the factory, throw an error if the function isn't registered.
    *   \param std::string typeName : the type name of the class containing the member function.
    *   \param std::string funcName : the name of the member function.
    *   \param std::string funcArgs : the name of the types of the member function's argument list to call.
    *   \param A&& args.... : the value of the arguments to pass to the callback's member function. (object + arguments)
    */
    template <typename... A>
    static void callFunction(std::string typeName, std::string funcName, std::string funcArgs, A&&... args) {
        typename std::map<std::string, FastDelegate<void>>::iterator it = functions.find(typeName+funcName+funcArgs);
        if (it != functions.end()) {
            it->second.setParams(std::forward<A>(args)...);
            (it->second)();
        } else {
            throw Erreur(0, "Unregistred function exception!", 1);
        }
    }
    /** \fn B* create (std::string typeName)
    *   \brief return a pointer of the base class of an object which point to an object of a derived type.
    * this function call a callback function to an allocator function to allocate the object.
    *   \param the typeName of the type to allocate.
    *   \return B* a pointer of a base class which'll point to the allocated object.
    */
    static B* create (std::string typeName) {
        typename std::map<std::string, FastDelegate<B*>>::iterator it = types.find(typeName);
        if (it != types.end()) {
            return (it->second)();
        }
        throw Erreur(0, "Unregistred type exception!", 1);
    }
    /** \fn std::string getTypeName (B* type)
    *   \brief return the type name of a base object.
    *   \param B* type : a pointer to the type to check the dynamic type name.
    *   \return the dynamic type name of the passed object*/
    static std::string getTypeName (B* type) {
        typename std::map<std::string, FastDelegate<B*>>::iterator it = types.find(typeid(*type).name());
        if (it != types.end())
            return it->first;
    }
    private :
    static std::map<std::string, FastDelegate<B*>> types; /**> An std::map which store the typeName and a callback's function to an allocator of the registered types*/
    static std::map<std::string, FastDelegate<void>> functions; /**> An std::map which store the signature and a callback's function to the registered member's functions.*/
};
template <typename B>
std::map<std::string, FastDelegate<B*>> BaseFactory<B>::types = std::map<std::string, FastDelegate<B*>>();
template <typename B>
std::map<std::string, FastDelegate<void>> BaseFactory<B>::functions = std::map<std::string, FastDelegate<void>>();
}
#endif

Bref c'est que j'utilise pour les plugins, j'enregistre tous les types puis je les instancie (en revoyant un pointeurs vers l'interface de base) et je fais la même chose pour les fonctions, en faisant un cast du pointeur l'interface de base vers le type dynamic de la classe avant d'appeler le pointeur sur la fonction de la librairie)

Lors de l'initialisation de la librairie (avec une méthode init) tu n'as qu'à enregistrer tout les types et tout les pointeurs sur fonctions pour tout les types dans la factory, l'utilisateur n'a plus qu'à initialisé la librairie, puis, appeler les fonctions via la factory en passant le nom de la classe et le nom de la fonction a appeler.

(Sauf si tes fonctions ne sont pas template alors là tu peux utiliser des fonctions virtuelles et te contenter d'enregistrer juste le type)

18/09/2014, 14h50
ikeas

Citation:

Envoyé par Lolilolight

Ca ressemble fort à ce que j'essaye de faire.

ben moi ça marche j'ai même rajouté dans le template un code pour vérifier a la compilation que la classe Type dérive bien de Interface
bon même si le message d'erreur est pas super explicite ....
18/09/2014, 18h15
Invité

Bah moi aussi ça marche, pourquoi avoir créer le sujet alors ? :o
18/09/2014, 19h24
Flob90
@Lolilolight: Pour avoir des avis ?

@OP: Quelques remarques et questions :
1. Pourquoi du static dans ta classe ? C'est vraiment nécessaire ?
2. Pourquoi tu mets ta map en pointeur ?
3. Pourquoi base_constructor et pas directement le std::function qui va bien ?
4. J'aurais tendance à préférer un std::unique_ptr plutôt que des pointeurs nus ici.
18/09/2014, 22h36
ikeas

Citation:

Envoyé par Lolilolight

Bah moi aussi ça marche, pourquoi avoir créer le sujet alors ? :o

je voulais savoir si mon template était bien ecrit
18/09/2014, 22h42
ikeas

Citation:

Envoyé par Flob90

Pourquoi du static dans ta classe ? C'est vraiment nécessaire ?

ca me semblait être plus intéressant qu'un objet instancié et plus facil d'acces aussi

Citation:

Envoyé par Flob90

Pourquoi tu mets ta map en pointeur ?

c'est vrai je me suis aussi posé la question elle pourrait ne pas etre en pointeur...

Citation:

Envoyé par Flob90

Pourquoi base_constructor et pas directement le std::function qui va bien ?

si tu peux me donner un exemple de la std::function qui va bien, je suis preneur

Citation:

Envoyé par Flob90

J'aurais tendance à préférer un std::unique_ptr plutôt que des pointeurs nus ici.

en fait je ne sais pas ce que c'est qu'un std::unique_ptr et si tel est le cas si avec celui ci tu peux manipuler l'objet retourné normalement
si tu as un exemple aussi je suis preneur

Citation:

Envoyé par ikeas

ca me semblait être plus intéressant qu'un objet instancié et plus facil d'acces aussi

Peut-être aux premiers abord mais ceci limite grandement l'usage, il est impossible d'avoir plusieurs référenceur. Et comme tous le monde y a accès il est difficile de savoir qui le modifie.

Citation:

Envoyé par ikeas

c'est vrai je me suis aussi posé la question elle pourrait ne pas etre en pointeur...

Pareil pour le vecteur. Il y a très peu de raison de faire un pointeur sur conteneur et encore moins de faire des allocations dynamique dessus. En plus cela alourdie l'écriture ; utiliser l'opérateur [] avec des pointeurs intermédiaires n'est pas très jolie.

Citation:

Envoyé par ikeas

si tu peux me donner un exemple de la std::function qui va bien, je suis preneur
Code:

1 2 3 4 5 6 7 8 template<class T> struct maker { void * operator()() { return new T; } }; Referencies<Interface>::Add(type_name<Type>(), []{ return new Type; }); Referencies<Interface>::Add(type_name<Type>(), maker<Type>());
La fonction create est remplacé par un opérateur ().

Mais pourquoi retourner void* plutôt que Interface* ? (et je rejoins Flob90 pour le unique_ptr.)

Pour le unique_ptr, réponse de Flob90 sur un sujet un peu plus bas.

22/09/2014, 07h10
ikeas

Citation:

Envoyé par jo_link_noir

Mais pourquoi retourner void* plutôt que Interface* ?

Mon idée premier était justement de renvoyer Interface, mais je crois que j'ai eu du mal avec la map pour l’écriture