Wie kann ich die map::find-operation mit groß-und Kleinschreibung?

Es nicht standardmäßig. Sie müssen eine benutzerdefinierte Komparator-als drittes argument. Folgendes snippet hilft Ihnen...

  /************************************************************************/
  /* Comparator for case-insensitive comparison in STL assos. containers  */
  /************************************************************************/
  struct ci_less : std::binary_function<std::string, std::string, bool>
  {
    //case-independent (ci) compare_less binary function
    struct nocase_compare : public std::binary_function<unsigned char,unsigned char,bool> 
    {
      bool operator() (const unsigned char& c1, const unsigned char& c2) const {
          return tolower (c1) < tolower (c2); 
      }
    };
    bool operator() (const std::string & s1, const std::string & s2) const {
      return std::lexicographical_compare 
        (s1.begin (), s1.end (),   //source range
        s2.begin (), s2.end (),   //dest range
        nocase_compare ());  //comparison
    }
  };

Verwenden Sie es wie std::map< std::string, std::vector<std::string>, ci_less > myMap;

HINWEIS: std::lexicographical_compare hat einige nitty-gritty details. String-Vergleich ist nicht immer einfach, wenn man bedenkt, locales. Sehen diese thread auf c.l.c++, wenn interessiert.

UPDATE: Mit C++11 std::binary_function ist veraltet und unnötig, denn die Typen werden automatisch abgeleitet.

  struct ci_less
  {
    //case-independent (ci) compare_less binary function
    struct nocase_compare
    {
      bool operator() (const unsigned char& c1, const unsigned char& c2) const {
          return tolower (c1) < tolower (c2); 
      }
    };
    bool operator() (const std::string & s1, const std::string & s2) const {
      return std::lexicographical_compare 
        (s1.begin (), s1.end (),   //source range
        s2.begin (), s2.end (),   //dest range
        nocase_compare ());  //comparison
    }
  };

Können Sie instanziieren std::map mit drei Parameter: Art der Tasten, der Art der Werte, und Vergleich-Funktion -- ein strict weak ordering (im wesentlichen, eine Funktion oder Funktor, verhält sich wie operator< in Bezug auf die Transitivität und anti-Reflexivität), das Ihren wünschen entspricht. Legen Sie den Dritten parameter das zu tun", groß- /Kleinschreibung nicht weniger-als" (z.B. durch eine < auf die kleingeschrieben werden strings es ist Vergleich) und Sie haben den "groß- /Kleinschreibung Karte", die Sie sich wünschen!

In Fall, dass Sie nicht möchten, berühren Sie den map-Typ (halten Sie ursprüngliche Einfachheit und Effizienz), aber nicht dagegen, mit einem langsameren groß- /Kleinschreibung zu suchen-Funktion (O(N)):

string to_lower(string s) {
    transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower );
    return s;
}

typedef map<string, int> map_type;

struct key_lcase_equal {
    string lcs;
    key_lcase_equal(const string& s) : lcs(to_lower(s)) {}
    bool operator()(const map_type::value_type& p) const {
        return to_lower(p.first) == lcs;
    }
};

map_type::iterator find_ignore_case(map_type& m, const string& s) {
    return find_if(m.begin(), m.end(), key_lcase_equal(s));
}

PS: Vielleicht war es Roger Pate ' s Idee, aber nicht sicher, da manche details waren ein wenig off (std::search?, direkte string-Vergleicher?)

Vergleichen element in der map-Vorlage standardmäßig einen binären Vergleich der Klasse "weniger". Blick auf die Implementierung:

http://www.cplusplus.com/reference/std/functional/less/

Können Sie wahrscheinlich erstellen Sie Ihre eigene Klasse, abgeleitet von binary_function (die übergeordnete Klasse weniger) und das gleiche tun Vergleich ohne groß-und Kleinschreibung.

Für C++11 und darüber hinaus:

#include <strings.h>
#include <map>
#include <string>

namespace detail
{

struct CaseInsensitiveComparator
{
    bool operator()(const std::string& a, const std::string& b) const noexcept
    {
        return ::strcasecmp(a.c_str(), b.c_str()) < 0;
    }
};

}   //namespace detail


template <typename T>
using CaseInsensitiveMap = std::map<std::string, T, detail::CaseInsensitiveComparator>;



int main(int argc, char* argv[])
{
    CaseInsensitiveMap<int> m;

    m["one"] = 1;
    std::cout << m.at("ONE") << "\n";

    return 0;
}

Möchte ich eine kurze Lösung ohne Verwendung von Boost-oder-Vorlagen. Da C++11 Sie können auch eine lambda-Ausdruck als benutzerdefinierte Komparator-zu Ihrer Karte. Für einen POSIX-kompatiblen system, die Lösung könnte wie folgt Aussehen:

auto comp = [](const std::string& s1, const std::string& s2) {
    return strcasecmp(s1.c_str(), s2.c_str()) < 0;
};
std::map<std::string, std::vector<std::string>, decltype(comp)> directory(comp);

Code auf Ideone

Für Fenster, strcasecmp() nicht vorhanden, aber Sie können _stricmp() statt:

auto comp = [](const std::string& s1, const std::string& s2) {
    return _stricmp(s1.c_str(), s2.c_str()) < 0;
};
std::map<std::string, std::vector<std::string>, decltype(comp)> directory(comp);

Hinweis: Abhängig von Ihrem system und Sie, ob diese Unicode unterstützen oder nicht, müssen Sie möglicherweise die strings vergleichen in einer anderen Weise. Dieses Q&A gibt einen guten start.