Opérateur de liaison nouveau?

Question

Je voudrais lier l'opérateur new (voir l'exemple ci-dessous). Si le constructeur n'a pas d'arguments, cela fonctionne bien, mais s'il a des arguments, j'ai apparemment du mal à obtenir la syntaxe de liaison correcte.

#include <map> 

#include <boost\function.hpp> 
#include <boost\lambda\lambda.hpp> 
#include <boost\lambda\construct.hpp> 
#include <boost\lambda\bind.hpp> 


enum TypeEnum 
{ 
    BarType, 
    BazType 
}; 

class Foo 
{ 

}; 

class Bar : public Foo 
{ 
    public: 
     Bar(int x) 
     { BarVal = x; } 

    private: 
     int barVal; 
}; 

class Baz : public Foo 
{ 
    public: 
     Baz(int x) 
     { bazVal = 2 * x; } 

    private: 
     int bazVal; 
}; 

class FooFactory 
{ 
    public: 
     FooFactory() 
     { 
      // How does this work? 
      factoryMap[BarType] = boost::lambda::bind(boost::lambda::new_ptr<Bar>(_1)); 
      factoryMap[BazType] = boost::lambda::bind(boost::lambda::new_ptr<Baz>(_1)); 
     } 

     Foo* getFoo(TypeEnum type, int z) 
     { 
      return factoryMap[type](z); 
     } 

    private: 
     std::map<TypeEnum, boost::function<Foo* (int)>> factoryMap; 
}; 

int main() 
{ 
    FooFactory fooFactory; 

    Bar *newBar = static_cast<Bar*> (fooFactory.getFoo(BarType, 10)); 

    return 0; 
} 

Answer 1

Cela devrait faire:

factoryMap[BarType] = boost::lambda::bind(boost::lambda::new_ptr<Bar>(), boost::lambda::_1); 
factoryMap[BazType] = boost::lambda::bind(boost::lambda::new_ptr<Baz>(), boost::lambda::_1); 

Answer 2

Pourquoi ne pas simplement d'écrire ce qui suit? Je ne vois aucune raison d'utiliser bind dans votre cas.

factoryMap[BarType] = boost::lambda::new_ptr<Bar>(); 
factoryMap[BazType] = boost::lambda::new_ptr<Baz>();