Tutoriel Boost In Place Factory

Avant toute chose, à l'instar de l'ensemble des bibliothèques Boost, le lecteur doit être familier avec le langage C++ et plus particulièrement se sentir à l'aise avec les templates. La bibliothèque In Place Factory utilise les bases de la programmation template. Il ne faut pas que celles-ci puissent être un obstacle à leur compréhension.

L'utilisation de la bibliothèque In Place Factory ne nécessite pas de connaissances particulières sur les autres bibliothèques Boost. L'implémentation, quant à elle, s'appuie sur Boost.Preprocessor. Sa compréhension nécessite donc d'avoir déjà côtoyé cette dernière.

Cette bibliothèque va permettre de masquer les paramètres de construction d'un objet à l'instance chargée de construire cet objet. Par exemple, supposons qu'une classe A ait besoin de construire un objet d'une classe B. Mais elle ne souhaite pas exposer dans son interface les paramètres nécessaires à la construction de B. In Place Factory va permettre d'atteindre ce but. Passons à un exemple concret pour plus de clarté :

class B
{
public:
   B(int _p0, double _p1, std::string _p2){}
};

class A
{
public:
    A();
private:
    B*m_pObjetB;
};

_{Juste un petit préambule pour préciser que ceci n'a vocation à être qu'un exemple pour la bibliothèque In Place Factory. En ce sens, une classe comme A devrait être plus complète pour gérer correctement un membre pointeur (et, plus judicieusement, utiliser les pointeurs intelligents). Le lecteur est supposé être familier avec ces notions, c'est pourquoi l'exemple, pour plus de clarté, omet volontairement ces aspects.}

Pour que A puisse créer son objet de type B, nous avons les deux solutions suivantes :

void A::CreerB(const B& _copie_de_b)
{
    m_pObjetB = new B(_copie_de_b);
}

void A::CreerB(int _p0, double _p1, std::string _p2)
{
    m_pObjetB = new B(_p0, _p1, _p2);
}

• Utiliser une variable temporaire de type B en supposant que B est constructible par copie.
• Exposer l'interface du constructeur de B.

La première solution présente deux inconvénients majeurs : B doit être constructible par copie et une instance temporaire est utilisée pour cette construction. La seconde solution se passe de commentaire : en effet, la maintenance de ce genre de code devient rapidement laborieuse. Comment faire ?

Boost.In Place Factory va nous permettre de résoudre ce problème. Les lecteurs familiers avec la langue de Shakespeare auront déjà traduit le nom de la bibliothèque : usine sur place ! L'idée que sous-tend cette bibliothèque est de permettre la construction (usine) de B dans A (sur place) avec tout les paramètres nécessaires sans pour autant les fournir explicitement à la méthode A::CreerB.

Commençons par l'essentiel : les fichiers d'en-têtes nécessaires ! Ils se limitent aux deux selon le type souhaité :

• boost/utility/in_place_factory.hpp ;
• boost/utility/typed_in_place_factory.hpp

La bibliothèque est composée de deux familles de classes que nous allons appeler in_place_factory et typed_in_place_factory. Le premier fichier d'en-tête permet d'accéder à la première famille de classe, et le second … à la seconde. Les différences entre ces deux seront étudiées ci-dessous.

L'espace de nommage est :

namespace boost

Revenons à notre problème de départ. Nous avons donc les deux classes suivantes :

class B
{
public:
   B(int _p0, double _p1, std::string _p2){}
};

class A
{
public:
   A();
private:
    B*m_pObjetB;
};

Nous souhaitons adjoindre une méthode à la classe A pour créer l'instance B. Deux questions se posent : quels sont les paramètres de notre méthode et comment celle-ci sera définie. Soit, en reformulant, comment cela se passe du côté du conteneur (implémentation de notre méthode A::CreerB) et comment cela se passe pour un utilisateur de la classe A (les paramètres).
Du côté du conteneur, le problème des paramètres est éludé par l'utilisation d'un template :

template<class InPlaceFactoryT>
void A::CreerB(InPlaceFactoryT const&_Usine)
{
   m_pObjetB = reinterpret_cast<B*>(new char[sizeof(B)]);
   _Usine.template apply<B>(m_pObjetB);
}

La première ligne est une allocation de la taille nécessaire à un objet de type B. new char[sizeof(B)] se contente d'allouer un bloc mémoire de taille suffisante, l'adresse est ensuite transtypée en B* sans aucune vérification. L'objectif est bien de séparer l'allocation de B de l'appel au constructeur.
Le second paramètre fait appel à une méthode template de notre paramètre : InPlaceFactoryT::apply<B>. Cette méthode va appeler le constructeur de B avec l'ensemble des paramètres.

Maintenant, comment appeler cette fonction et quel est ce mystérieux paramètre InPlaceFactoryT ? L'interface apportée par Boost est encore là très simple :

À a;
a.CreerB(boost::in_place(1,3.14,"une chaine"));

Comme le montre cet exemple, la fonction boost::in_place permet de masquer la classe effectivement créée. Cela reste du ressort de la bibliothèque. Pour son utilisation, il n'est pas nécessaire d'en connaître plus. Nous reviendrons dessus dans les détails d'implémentation un peu plus loin.

En théorie, il est possible d'utiliser in_place_factory pour un tableau d'éléments. Une version surchargée prend le nombre d'éléments contenus dans le tableau :

template<class InPlaceFactoryT>
void A::Creer10B(InPlaceFactoryT const&_Usine)
{
   m_pObjetB = reinterpret_cast<B*>(new char[sizeof(B)*10]);
   _Usine.template apply<B>(m_pObjetB,10);
}

Les mêmes paramètres sont utilisés pour la construction de tous les éléments.

En théorie ? Oui, car ce code ne compile pas à cause de l'implémentation interne de la fonction apply. Dans la section précisant les détails d'implémentation, un contournement est proposé.

La différence entre Typed In Place Factory et In Place Factory tient, comme le nom l'indique, dans la précision du nom du type auquel s'applique la construction. Dans la version In Place Factory, le type de l'objet est indiqué du côté du conteneur au moment de l'appel à apply :

template<class InPlaceFactoryT>
void A::CreerB(InPlaceFactoryT const&_Usine)
{
   m_pObjetB = reinterpret_cast<B*>(new char[sizeof(B)]);
   _Usine.template apply<B>(m_pObjetB);
}

Dans la version Typed In Place Factory, le type est déclaré par l'utilisateur :

   À a;
   a.CreerB(boost::in_place<B>(1,3.14,"une chaine"));

Côté conteneur, cela devient tout simplement :

template<class InPlaceFactoryT>
void A::CreerB(InPlaceFactoryT const&_Usine)
{
   m_pObjetB = reinterpret_cast<B*>(new char[sizeof(B)]);
   _Usine.apply(m_pObjetB);
}

Quel est l'intérêt de Typed In Place Factory ? Lorsque la classe A n'a pas connaissance du type exact de B (par exemple, dans le cas où du polymorphisme intervient), cette connaissance est déléguée à l'appelant. L'exemple suivant illustre ce cas :

class BBase
{
};

class B : public BBase
{
public:
   B(int _p0, double _p1, std::string _p2);
   ~B();
};

class B2 : public BBase
{
public:
   B2();
   ~B2();
};

class A
{
public:
   A();
   ~A();
   template<class TypedInPlaceFactoryB>
   void CreerBBase(BBase*_pAdresse, TypedInPlaceFactoryB const&_Usine)
   {
      m_pObjetBase = _pAdresse;
      _Usine.apply(m_pObjetBase);
   }
protected:
   BBase *m_pObjetBase;
};

int main()
{
   À a;
   char un_b[sizeof(B)];
   a.CreerBBase(
      reinterpret_cast<BBase*>(&un_b)
      ,boost::in_place<B>(1,3.14,"une chaine")// On veut un B
   );

   char un_b2[sizeof(B2)];
   a.CreerBBase(
      reinterpret_cast<BBase*>(&un_b2)
      ,boost::in_place<B2>()// On veut un B2
   );

   return 0;
}

V-F-1. L'espace de stockage▲

V-F-2. Limites en nombre d'arguments▲

V-F-3. Durée de vie des arguments▲

La bibliothèque définit une classe selon le nombre de paramètres du constructeur. Ces classes sont :

• in_place_factory0 pour un constructeur sans paramètre ;
• in_place_factory1 pour un constructeur avec 1 paramètre ;
• in_place_factory2 pour un constructeur avec 2 paramètres ;
• … ;
• in_place_factoryN pour un constructeur avec N paramètres.

Chacune des classes suit le schéma suivant :

class in_place_factory_base {} ;
template<class A1, class A2, ..., class AN>
class in_place_factoryN
  :
  public in_place_factory_base
{
public:

  explicit in_place_factoryN
      ( A1 const& a1, A2 const& a2,..., AN const& aN)
    : m_a1(a1), m_a2(a2),...,m_aN(aN)
  {}

  template<class T>
  void* apply(void* address) const
  {
    return new(address) T( m_a1, m_a2,...,m_aN );
  }
  template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

  A1 const&m_a1;
  A2 const&m_a2;
  ...
  AN const&m_aN;
};

À l'instar des familles de classes, on retrouve une famille de fonctions in_place surchargées suivant le nombre d'arguments :

inline in_place_factory0 in_place(){
    return in_place_factory0();
}
template<class A1>
inline in_place_factory1 in_place(A1 const &a1){
    return in_place_factory1<A1>(a1);
}
template<class A1, class A2>
inline in_place_factory1 in_place(A1 const &a1, A2 const &a2){
    return in_place_factory2<A1,A2>(a1, a2);
}

...
template<class A1, class A2, ... class AN>
inline in_place_factoryn in_place(A1 const &a1, A2 const &a2, ..., AN const &aN){
    return in_place_factoryN<A1,A2,...,AN>(a1, a2,...,aN);
}

Chacune de ces fonctions crée une instance de la classe adéquate et la retourne. Pourquoi passer par de telles fonctions ? Tout simplement pour avoir une interface uniforme qui va masquer à l'utilisateur le détail des différentes classes existantes. En effet, le compilateur sait quelle surcharge choisir grâce au nombre d'arguments.

Les classes typed_in_place_factory se différencient des classes in_place_factory sur la remontée du template de la classe à construire, de la méthode apply vers la classe typed_in_place_factory elle-même. On retrouve donc une implémentation similaire :

class typed_in_place_factory_base {} ;

template< class T, class A1, class A2, ..., class AN >
class typed_in_place_factoryN
  : 
  public typed_in_place_factory_base
{
public:

  typedef T value_type;

  explicit typed_in_place_factoryN
      ( A1 const& a1, A2 const& a2,...,AN const& aN)
    : m_a1(a1),m_a2(a2),...m_aN(aN)
  {}

  void* apply (void* address) const
  {
    return new(address) T( m_a1, m_a2,...,m_aN );
  }

  void* apply (void* address, std::size_t n) const
  {
    for(void* next = address = this->apply(address); !! --n;)
      this->apply(next = static_cast<char *>(next) + sizeof(T));
    return address; 
  }

  A1 const&m_a1;
  A2 const&m_a2;
  ...
  AN const&m_aN;
};

template< class T, class A1, class A2,..., class AN>
inline typed_in_place_factoryN<
    T, A1, A2,..., AN>
in_place( A1 const& a1,A2 const& a2,...,AN const& aN )
{
  return typed_in_place_factoryN< 
      T, A1, A2,..., AN >( a1, a2,..., aN);
}

VI-D-1. Boost.Preprocessor▲

#if N > 0
template< BOOST_PP_ENUM_PARAMS(N, class A) >
inline BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
in_place( BOOST_PP_ENUM_BINARY_PARAMS(N, A, const& a) )
{
  return BOOST_PP_CAT(in_place_factory,N)< BOOST_PP_ENUM_PARAMS(N, A) >
      ( BOOST_PP_ENUM_PARAMS(N, a) );
}
#else
inline in_place_factory0 in_place()
{
  return in_place_factory0();
}
#endif

VI-D-2. Limite du nombre d'arguments▲

Précédemment, on a laissé entendre que l'on pouvait utiliser l'initialisation sur place aussi pour un tableau :

template<class InPlaceFactoryT>
void A::Creer10B(InPlaceFactoryT const&_Usine)
{
   m_pObjetB = reinterpret_cast<B*>(new char[sizeof(B)*10]);
   _Usine.template apply<B>(m_pObjetB,10);
}

Cependant, si vous compilez ce code, vous obtiendrez probablement une erreur du type :

in_place_factory.hpp:61: error: invalid conversion from `void*' to `char*'

En effet, si on reprend la définition de la classe :

template<class T>
  void* apply(void* address, std::size_t n) const
  {
    for(char* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = next+sizeof(T));
    return address;
  }

À noter que la définition des classes typed_in_place_factory ne pose aucun souci de compilation :

void* apply (void* address, std::size_t n) const
{
    for(void* next = address = this->apply(address); !! --n;)
      this->apply(next = static_cast<char *>(next) + sizeof(T));
    return address; 
}

Il ne nous reste donc qu'à modifier les classes in_place_factory en ce sens.

template<class T>
void* apply(void* address, std::size_t n) const
{
    for(void* next = address = this->template apply<T>(address);
        !! --n;)
      this->template apply<T>(next = static_cast<char *>(next) + sizeof(T));
    return address;
}