Discussion :

[Veovis]

Salut,

Est ce qu'il est possible d'appeller une fonction via le nom de cette fonction (string). Je m'explique :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
 
int toto() {
 
}
 
int main() {
    string t = "toto()";
    //pouvoir appeller la fonction via ce string
}

Merci pour les r�ponses....

[Luc Hermitte]

Non.
C'est � toi d'associer tes chaines � des fonctions (boost::bind et boost::function peuvent �tre une piste de r�ponse). Si en plus tu dois passer des arguments, cela devient encore plus compliqu�.

[Veovis]

Oki merci je vais aller voir du c�t� de ses fonctions (bind et fonction).

[loufoque]

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
#include <iostream>
#include <map>
 
void toto()
{
     std::cout << "Je suis la fonction toto" << std::endl;
}
 
int main()
{
    std::map<std::string, void(*)()> map;
    map["toto"] = &toto;
 
    map["toto"]();
}

[Vitis_Alba]

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
#include <iostream>
#include <map>
 
void toto()
{
     std::cout << "Je suis la fonction toto" << std::endl;
}
 
int main()
{
    std::map<std::string, void(*)()> map;
    map["toto"] = &toto;
 
    map["toto"]();
}

Salut,

Je souhaiterais utiliser cette m�thode, mais pas avec des fonction, plut�t avec des constructeurs. Par contre, je ne vois pas comment m'y prendre. Cela est il possible?

[M�dinoc]

Pour des constructeurs, renseigne-toi sur le pattern "factory".

[Vitis_Alba]

Pour des constructeurs, renseigne-toi sur le pattern "factory".

Je r�cup�re une chaine de caract�res depuis un parser, et suivant la chaine en question, je veux cr�er l'objet qui lui correspond.
Je ne comprends pas commment le pattern factory peut m'aider dans ce cas. Tu pourrais m'�clairer ?

[loufoque]

Je souhaiterais utiliser cette m�thode, mais pas avec des fonction, plut�t avec des constructeurs. Par contre, je ne vois pas comment m'y prendre. Cela est il possible?

Si tu veux uniquement stocker les constructeurs par d�faut, peut-�tre.
Je sais pas si on peut avoir un pointeur vers un constructeur par contre.

[M�dinoc]

Le pattern factory, �a peut �tre un ensemble de pointeurs vers des fonctions qui font juste un new...

Un petit pseudocode:

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
class CClasseDeBaseObjetDynamique;
class CUneClasse : public CClasseDeBaseObjetDynamique;
class CUneAutreClasse : public CClasseDeBaseObjetDynamique;
 
CClasseDeBaseObjetDynamique * CreerObjetDUneClasse(void)
{
   return new CUneClasse;
}
 
CClasseDeBaseObjetDynamique * CreerObjetDUneAutreClasse(void)
{
   return new CUneAutreClasse;
}
 
typedef CClasseDeBaseObjetDynamique (*FonctionCreatrice)(void)
map< string, FonctionCreatrice > g_fonctions;
 
void Initialiser(void)
{
   g_fonctions["UneClasse"] = CreerObjetDUneClasse;
   g_fonctions["UneAutreClasse"] = CreerObjetDUneAutreClasse;
}
 
CClasseDeBaseObjetDynamique * CreeObjet(string nomClasse)
{
   FonctionCreatrice fonc = g_fonctions[nomClasse];
   if( fonc==NULL )
      return NULL;
   CClasseDeBaseObjetDynamique * obj = fonc();
   return obj;
}

[loufoque]

On peut faire plus g�n�rique, plus simple, et sans utiliser new (qui impose allocation dynamique).

[M�dinoc]

OK, je laisse faire le ma�tre.
Montre ta m�thode.

[loufoque]

On peut essayer de faire un truc similaire � boost::function.

J'ai aussi �crit �a vite fait sans tester, y'a peut-�tre des erreurs.
Et puis l'interface peut aussi �tre am�lior�e.

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
namespace detail
{
     template<typename T>
     void ctor_apply(void* p)
     {
          new(p) T;
     }
}
 
// un simple indicateur
template<typename T>
struct constructor_type
{
};
 
class constructor
{
    template<typename T>
    constructor(constructor_type<T>)
    {
        ctor_ = &detail::ctor_apply<T>;
    }
 
    template<typename T>
    constructor& operator=(constructor_type<T>)
    {
        ctor_ = &detail::ctor_apply<T>;
    }
 
    constructor& operator=(const constructor &c)
    {
         ctor_ = c.ctor_;
    }
 
    void apply(void *p)
    {
        ctor_(p);
    }
 
private:
    void (*ctor_)(void*);
};

un constructor peut alors contenir le constructeur par d�faut de n'importe quel type.

Avec une technique similaire et si on disposait des fonctions virtuelles templates, on pourrait m�me appeler un constructeur prenant n'importe quel nombre de param�tres.

[Vitis_Alba]

Je vous remercie pour vos r�ponses, j'ai pour l'instant cod� la m�thode qui utilise la factory.

Loufoque ( ou quelqu'un d'autre, apr�s tout ), pourrais tu me donner un petit exemple d'tulisation de ton code, car j'ai un peu de mal � suivre mais je voudrais bien comprendre.

[David Fleury]

[code]namespace detail
{
template<typename T>
void ctor_apply(void* p)
{
new(p) T;
}
}

Cool la m�thode.

Mais j'ai quand m�me deux questions (points pas clair pour moi encore)
:
1. Le placement new ne poserait pas probl�me dans le cas d'un h�ritage avec des enfants de taille sup�rieure ?

2. Je ne vois pas trop comment utiliser ta m�thode avec des classes virtuelles (on aurait plus tendance � vouloir r�cup�rer un pointeur sur l'objet cr��).

[loufoque]

L'id�e de constructor est d'avoir une variable qui peut "contenir" le constructeur par d�faut de n'importe quel type.
Tu l'informes du type � contenir en utilisant constructor_type.

Tu construis alors ton objet en fournissant � la fonction apply une adresse vers un emplacement m�moire suffisamment grand et avec un alignement compatible avec les objets de type que tu veux cr�er.
Malheureusement c'est vrai qu'en fait il aurait �t� pas mal que ce soit constructor qui se charge d'allouer l'objet, parce que sinon on ne connait pas le type, et donc pas la taille, de l'objet � allouer.

Peut-�tre qu'utiliser une interface d'allocateurs permettrait une meilleure souplesse, pour pouvoir exploiter le cas o� l'on connait la taille.

Mais comment alors lib�rer l'objet cr�� ? En rajoutant un second pointeur de fonction vers une fonction qui appelle delete par exemple. (On plut�t, pour optimiser la taille, en ayant un pointeur vers une classe polymorphe qui contiendrait ces deux fonctions)

Mais si on suit le RAII, alors l'objet doit �tre responsable de la destruction des objets qu'il cr��. Ce qui signifie alors que l'objet doit �tre contenu. Donc du coup, �a revient � coder boost.any.

Ou alors on se restreint au polymorphisme et � new/delete et on retourne des shared_ptr.
Ce qui correspond mieux � l'id�e du Design Pattern Factory.

[David Fleury]

La solution par allocator me semble trop th�orique.

Mais si on suit le RAII, alors l'objet doit �tre responsable de la destruction des objets qu'il cr��. Ce qui signifie alors que l'objet doit �tre contenu. Donc du coup, �a revient � coder boost.any.

Ou alors on se restreint au polymorphisme et � new/delete et on retourne des shared_ptr.
Ce qui correspond mieux � l'id�e du Design Pattern Factory.

Un simple auto_ptr suffirait pour expliciter le passage de responsibilit� sur la d�sallocation.

[loufoque]

Faire un delete sur un type diff�rent de celui utilis� lors du new correspondant est un comportement ind�fini.
� part si le type est une base de celui utilis� lors du new et si le destructeur est virtuel.

D'o� la simplicit� gagn�e en se restreignant au polymorphisme et � new/delete.
(Cette fonctionnalit� n'est pas possible avec les allocateurs, il faut absolument que le type utilis� pour la d�sallocation soit le m�me que pour l'allocation)

[David Fleury]

Je me demande si je n'ai pas d�j� vu une impl�mentation de ta proposition par allocator dans le livre d'Alexandrescu Modern C++ Design, o� il met en place une farbrique de ce style. (peut �tre est-elle dispo dans loki)