remplacer la carte::comparer avec fonction lambda directement

Essayer de passer outre map::compare fonction à l'aide de lambda, il semble que la solution suivante œuvres.

auto cmp = [](const int&a, const int& b) { return a < b; };
std::map<int, int, decltype(cmp)> myMap(cmp);

Mais, j'ai dû définir cmp premier et l'utiliser plus tard.

Puis-je le faire sans que la définition de 'cmp'?

  • cmp n'est pas un pointeur de fonction.
  • Faire quoi? ints déjà de les comparer les uns aux autres. Qu'essayez-vous de faire? Et pourquoi ne veux-tu pas utiliser une fonction?
  • Ouais, pointeur de fonction n'était pas un terme précis. Modifié la question de rendre la question plus claire.
  • Alors, quelle approche avez-vous utilisé qui a échoué? Nous savons que vous voulez quelque chose autre que votre exemple, mais pas ce que votre objectif ultime est.
  • Mais ne peut pas captureless lambas être converti en un pointeur de fonction?
InformationsquelleAutor MBZ | 2013-08-04
  1. 15

    Non, vous ne peut pas utilisation lambda non évaluées dans le contexte: c'est à dire les paramètres de modèle comme dans votre exemple.
    Si vous doit définir quelque part d'autre (à l'aide de auto) et ensuite utiliser decltype... dans l'autre sens, comme il a été déjà mentionné, est d'utiliser un "ordinal" foncteurs

    Si votre question est à propos de "comment utiliser l'expression lambda *une fois* lorsque vous définissez une carte", vous pouvez exploiter la conversion implicite de lambdas à std::function comme ceci:

    #include <iostream>
#include <functional>
#include <map>

int main()
{
    auto m = std::map<int, int, std::function<bool(const int&, const int&)>>{
        [](const int& a, const int& b)
        {
            return a < b;
        }
    };
    return 0;
}

    vous pouvez introduire un alias pour que map type à réduire la frappe plus tard...

    • Cependant, l'utilisation de std::function ajouterait un niveau d'indirection et de le rendre moins efficace.
    InformationsquelleAutor zaufi
  2. 6
    #include <iostream>
#include <functional>
#include <map>
#include <typeinfo>

typedef std::map< int, int, std::function<bool(const int&, const int&)> > MyMap;

int main()
{
    auto cmp = [](const int& a, const int& b) { return a < b; };
    MyMap map(cmp);

    return 0;
}

    À l'aide de std::function à donner le type de signature pour le comparateur type vous pouvez définir votre type de carte, puis assigner n'importe quel lambda comparez vous le souhaitez.

    • C'est ce que l'OP demande, mais vraiment, l'introduction de std::function se sent comme une mauvaise solution. Un alias de modèle, à la place? template<typename Comp> using MyMap = std::map<int, int, Comp>; et puis vous n'avez pas à définir le comparateur jusqu'à ce que vous instanciez la carte.
    • Je suis coincé avec un être inférieur compilateur (VS2012) qui n'a pas de modèle de prise en charge des alias, donc je n'ai aucune expérience avec eux.
    • modèle alias n'aidera pas de toute façon: vous ne pouvez pas utiliser lambda non évaluées dans le contexte, mais vous devez spécifier un Comp paramètre de toute façon (au point d'instanciation).
    • mais vous pouvez utiliser std::function<> dans un modèle d'alias. voir mon post par exemple. En fait, je pense std::function ins est pas une mauvaise solution si il y a une raison convaincante pour gérer plusieurs cartes avec beaucoup de différents comparateurs surtout si certains de capture d'une variable (dans ce cas, l'arbitraire d'un certain nombre de comparaisons qui peuvent exister).
    InformationsquelleAutor Borgleader
  3. 4

    Que vous pourriez faire quelque chose comme ça où le type de la carte est déduit de la fonction de vous transmettre à une fonction.

    #include <map>

template<class Key, class Value, class F>
std::map<Key, Value, F> make_map(const F& f) {
    return std::map<Key, Value, F>{f};
}

int main() {
    auto my_map = make_map<int, int>([](const int&a, const int& b) { return a < b; });
    my_map[10] = 20;
}

    Je ne vois pas une tonne de raisons pour cela, mais je ne vais pas dire que c'est inutile. En général, vous voulez un connu comparateur de sorte que la carte peut être transmis facilement. Avec la configuration ci-dessus vous sont réduits à l'aide de modèle de fonctions tout le temps comme suit

    tempalte<class F>
void do_somthing(const std::map<int, int, F>& m) {

}

    Ce n'est pas nécessairement mauvais, mais mon instinct me dire que le fait d'avoir un type qui ne peuvent être traitées par des fonctions génériques est mauvais. Je pense qu'il fonctionne bien pour les lambda fonctions, mais c'est tout. La solution ici est d'utiliser std::function

    #include <map>
#include <functional>

template<class Key, class Value>
using my_map_t = std::map<Key, Value, std::function<bool(const Key&, const Key&)>>;

int main() {
    my_map_t<int,  int> my_map{[](const int&a, const int& b) { return a < b; }};
    my_map[10] = 20;
}

    Maintenant vous pouvez utiliser n'importe quel prédicat que vous voulez et vous avez un type de béton à travailler avec, my_map

    espérons que cette aide!

    InformationsquelleAutor Jake