Lambda polymorphique du C++14

Introduction

J’avais déjà abordé dans un article précédent les limites des lambdas du C++11. Le C++14 offre maintenant des lambdas polymorphiques qui suppriment cette limite. A la place de reprendre les exemples que j’avais élaboré lors de ce premier article, je vais plutôt réécrire la partie de mon article Comportement dynamique qui implique l’utilisation d’une lambda polymorphique.

Rappel

Voici donc la partie du code concernée :

#include<boost/functional/value_factory.hpp>

#include<boost/phoenix/core.hpp>
#include<boost/phoenix/function.hpp>

namespace phoenix   = boost::phoenix;

struct PopulateType {
    template<class...>
    struct result
    { typedef void type; };

    template<class Factories, class T>
    void operator()(
        Factories& factories,
        const Id<typename Factories::key_type,T>& i) const
    { factories[i.id]=boost::value_factory<T>(); }
};

phoenix::function<PopulateType> const populate;

using phoenix::placeholders::arg1;

mpl::for_each<SeqShape,Id<KeyType,_>>
    (populate(phoenix::ref(factories),arg1));

La lambda polymorphique se faisait au moyen de boost.phoenix, son utilisation est assez lourde par l’introduction d’une classe supplémentaire. Cependant cette classe fait aussi correspondre le type de l’argument avec un modèle pour en extraire l’information utile (le T). Cette extraction restera nécessaire avec une lambda polymorphique telle que le propose le C++14.

Nouveau code

On peut réécrire le code ainsi :

#include<boost/functional/value_factory.hpp>

template<class>
struct ObjType;

template<class Key, class T>
struct ObjType<Id<Key,T>>
{ typedef T type; };

mpl::for_each<SeqShape,Id<KeyType,_>> (
    [&factories](const auto& i) {
        typedef typename ::boost::remove_const<
            typename ::boost::remove_reference<decltype(i)>::type
        >::type IdType;
        factories[i.id]=
            ::boost::value_factory<typename ObjType<IdType>::type>();
    }
);

On peut déjà remarquer que l’introduction de la classe servant à extraire l’information utile, ObjType, est bien plus concise que ne l’était la classe introduite pour le foncteur polymorphique de boost.phoenix. On voit aussi que le calcul du type IdType est plus complexe dans cette situation car on ne profite plus de la déduction des paramètres template.

Publicités

Une réflexion au sujet de « Lambda polymorphique du C++14 »

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s