C ++ 0x: Stocker tout type de std :: Fonction dans une carte STD :: Carte

Vous pouvez utiliser Dynamic Cast pour déterminer le type de fonction de la liste au moment de l'exécution. Veuillez noter que j'ai ajouté Shared_Ptr pour supprimer la fuite de mémoire dans l'échantillon d'origine. Peut-être que vous voulez jeter une exception si la méthode d'exécution est appelée avec les mauvais arguments (si le dynamic_cast donne 0).

Utilisation: p>

#include <functional>
#include <map>
#include <string>
#include <memory>

using namespace std;
class Ignored;

class BaseCommand
{
public:
    virtual ~BaseCommand() = 0 {};
};

template <class A1 = Ignored>
class Command : public BaseCommand
{
  typedef std::function<void(A1)> FuncType;
  FuncType f_;
  public:
    Command() {}
    Command(FuncType f) : f_(f) {}
    void operator()(const A1& a1) { if(f_) f_(a1); }
};

template <>
class Command<Ignored> : public BaseCommand
{
  typedef std::function<void()> FuncType;
  FuncType f_;
  public:
    Command() {}
    Command(FuncType f) : f_(f) {}
    void operator()() { if(f_) f_(); }
};

class CommandManager
{
  typedef shared_ptr<BaseCommand> BaseCommandPtr;
  typedef map<string, BaseCommandPtr> FMap;
  public :

  template <class T>
  void add(string name, const T& cmd)
  {
     fmap1.insert(pair<string, BaseCommandPtr>(name, BaseCommandPtr(new T(cmd))));
  }

  template <class A1>
  void execute(string name, const A1& a1)
  {
    typedef Command<A1> CommandType;
    FMap::const_iterator it = fmap1.find(name);
    if(it != fmap1.end())
    {
      CommandType* c = dynamic_cast<CommandType*>(it->second.get());
      if(c)
      {
        (*c)(a1);
      }
    }
  } 

  void execute(string name)
  {
    typedef Command<> CommandType;
    FMap::const_iterator it = fmap1.find(name);
    if(it != fmap1.end())
    {
      CommandType* c = dynamic_cast<CommandType*>(it->second.get());
      if(c)
      {
        (*c)();
      }
    }
  }
  private :
    FMap fmap1;
};

Qu'est-ce que vous essayez de faire n'est pas possible sans quelques travaux d'exécution sérieux et le coût associé. La solution la plus simple ne ferait bien sûr que stocker un boost :: n'importe quel < / a> ( any_function ne s'est jamais rendu en boost) à l'intérieur de votre carte et faites les coulées nécessaires (ou ajoutez des données d'exécution qui vous indique qui moulant à faire), bien que vous puissiez éviter cela à tout prix et aller avec des arguments fixes ou aucun argument. Vos utilisateurs peuvent ensuite modifier leurs fonctions à l'aide de lidez pour correspondre à la signature souhaitée.

Edit: Dans votre schéma actuel, je ne vois aucune raison pour CommandManager pour stocker Commande * sur la carte.

Edit2: Vous déposez également le type de retour. Cela pourrait être ok pour votre cas d'utilisation mais rend cela beaucoup moins de générique.

Edit3: J'ai élaboré un exemple de travail de votre code en utilisant tout . Je pense qu'il y a une faille et je ne vois vraiment pas ce que cela devrait atteindre mais ici, il va: xxx

comme pour l'exemple en utilisant une signature fixe. Pensez simplement à ce qui serait la représentation la plus naturelle d'une fonction que vous allez stocker (en regardant votre commande , je suppose que c'est std :: fonction . Stockez les fonctions de ce type et chaque fois que vos utilisateurs essaient de l'utiliser, il doit BIND Quelle que soit la fonction qu'il souhaite utiliser, il correspond donc à cette signature.