Expressions Lambda en tant que paramètres de modèle de classe

Question

Les expressions lambda peuvent-elles être utilisées comme paramètres de modèle de classe? (Notez que c'est une question très différente de celle-ci, qui demande si une expression lambda elle-même peut être templatisée.)

Je demande si vous pouvez faire quelque chose comme :

template  
struct Foo { };
// ...
Foovoid { })> foo;

Ce serait utile dans des cas où, par exemple, un modèle de classe a divers paramètres comme equal_to ou quelque chose du genre, qui sont généralement implémentés comme des foncteurs d'une ligne. Par exemple, supposons que je veuille instancier une table de hachage qui utilise ma propre fonction de comparaison d'égalité personnalisée. J'aimerais être capable de dire quelque chose comme :

typedef std::unordered_map<
  std::string,
  std::string,
  std::hash,
  decltype([](const std::string& s1, const std::string& s2)->bool 
    { /* Implémentation personnalisée de equal_to */ })
  > map_type;

Mais j'ai testé ceci sur GCC 4.4 et 4.6, et cela ne fonctionne pas, apparemment parce que le type anonyme créé par une expression lambda n'a pas de constructeur par défaut. (Je me souviens d'un problème similaire avec boost::bind.) Y a-t-il une raison pour laquelle le projet de norme ne le permet pas, ou est-ce que je me trompe et que c'est autorisé mais que GCC est simplement en retard dans leur implémentation?

Answer 1

Dès C++20, cette réponse est maintenant obsolète. C++20 introduit des lambdas sans état dans des contextes non évalués1:

Cette restriction a été initialement conçue pour empêcher que les lambdas n'apparaissent dans des signatures, ce qui aurait ouvert une boîte de vers pour le mangled, car les lambdas doivent avoir des types uniques. Cependant, la restriction est beaucoup plus forte qu'elle ne devrait l'être, et il est en effet possible d'obtenir le même effet sans elle.

Certaines restrictions sont toujours en place (par exemple, les lambdas ne peuvent toujours pas apparaître dans les signatures de fonction), mais l'utilisation décrite est maintenant complètement valide et la déclaration d'une variable n'est plus nécessaire.

---

Je demande si vous pouvez faire quelque chose comme :

Foo<decltype([]()->void { })> foo;

Non, vous ne pouvez pas, car les expressions lambda ne doivent pas apparaître dans un contexte non évalué (tel que decltype et sizeof, entre autres). C++0x FDIS, 5.1.2 [expr.prim.lambda] p2

L'évaluation d'une expression lambda aboutit à un prvalue temporaire (12.2). Ce temporaire est appelé l'objet de fermeture. Une expression lambda ne doit pas apparaître dans un opérande non évalué (Clause 5). [ Note : Un objet de fermeture se comporte comme un objet fonction (20.8).—fin de la note ] (soulignement ajouté)

Vous devriez d'abord créer une lambda spécifique, puis utiliser decltype sur celle-ci :

auto my_comp = [](const std::string& left, const std::string& right) -> bool {
  // whatever
}

typedef std::unordered_map<
  std::string,
  std::string,
  std::hash<std::string>,
  decltype(my_comp)
  > map_type;

Cela est dû au fait que chaque objet de fermeture dérivé d'une lambda pourrait avoir un type complètement différent, ce sont comme des fonctions anonymes après tout.

Answer 2

Réponse C++20 : oui !

Vous pouvez tout à fait faire quelque chose comme

Foovoid { })> foo;

Car c++20 autorise les lambdas sans état dans les contextes non évalués.

Answer 3

@Xeo vous a donné la raison, donc je vais vous donner la solution de contournement.

Il arrive souvent que vous ne souhaitez pas nommer une fermeture, dans ce cas, vous pouvez utiliser std::function, qui est un type :

typedef std::unordered_map<
  std::string,
  std::string,
  std::hash,
  std::function
  > map_type;

Notez qu'il capture exactement la signature de la fonction, sans plus.

Ensuite, vous pouvez simplement écrire la lambda lors de la construction de la carte.

Notez qu'avec unordered_map, si vous modifiez la comparaison d'égalité, vous feriez mieux de modifier le hachage pour correspondre au comportement. Les objets qui se comparent égaux doivent avoir le même hachage.

Answer 4

Vous ne pouvez pas faire cela avec une fermeture, car l'état n'est pas contenu dans le type.

Si votre lambda est sans état (pas de captures), alors vous devriez être bon. Dans ce cas, la lambda se dégrade en un pointeur de fonction ordinaire, que vous pouvez utiliser comme argument de modèle à la place d'un type lambda.

gcc n'aime pas ça cependant. http://ideone.com/bHM3n

Answer 5

Vous devrez utiliser soit un type abstrait d'exécution, comme std::function, soit créer le type en tant que variable locale ou en tant que partie d'une classe templatisée.