Fare la mappa :: trovare operazione senza distinzione tra maiuscole e minuscole

Question

Il metodo map :: find supporta la ricerca senza distinzione tra maiuscole e minuscole?
Ho una mappa come segue

map<string,vector<string> > directory; 

e desidera che la ricerca di seguito per ignorare caso.

directory.find(search_string); 

Answer 1

Non per impostazione predefinita. Dovrai fornire un comparatore personalizzato come terzo argomento. Seguente frammento vi aiuterà a ...

/************************************************************************/ 
    /* 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 
    } 
    }; 

Usalo come std::map< std::string, std::vector<std::string>, ci_less > myMap;

NOTA: std :: lexicographical_compare ha alcuni dettagli essenziali. Il confronto tra stringhe non è sempre semplice se si considerano locali. Vedere il thread this su c.l.C++ se interessato.

UPDATE: Con C++ 11 std::binary_function è obsoleto e non è necessario in quanto i tipi vengono dedotti automaticamente.

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 
    } 
    }; 

Answer 2

No, non si può fare che usare find come in quel caso non ci sarà più corrispondenze. Ad esempio, durante l'inserimento ti è stato fatto qualcosa come map["A"] = 1 e map["a"] = 2 e ora se vuoi una maiuscole/minuscole map.find("a") qual è il valore di ritorno previsto? Il modo più semplice per risolverlo è inserire la stringa in mappa in un solo caso (maiuscolo o minuscolo) e quindi utilizzare lo stesso caso mentre si esegue il rilevamento.

Answer 3

L'elemento Confronta del modello di mappa assume come valore predefinito una classe di confronto binario "inferiore". Guardate l'attuazione:

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

È possibile probabile creare la propria classe che deriva da binary_function (classe genitore a meno) e fare lo stesso confronto, senza maiuscole e minuscole.

Answer 4

È possibile istanziare std::map con tre parametri: tipo di chiavi, tipo di valori, e funzione di confronto - un rigoroso debole ordinare (essenzialmente, una funzione o funtore comportarsi come operator< in termini di transitività e anti-riflessività) di tuo gradimento. Basta definire il terzo parametro per fare "case-insensitive less-than" (ad es. Con un < sulle stringhe in minuscolo che sta confrontando) e avrai la "mappa insensibile alle maiuscole e minuscole" che desideri!

Answer 5

Implementare std :: meno funzione e confrontare cambiando entrambi nello stesso caso.

Answer 6

Nel caso in cui non si vuole toccare il tipo di mappa (per mantenere la sua semplicità originale ed efficienza), ma non mente utilizzando una funzione più lento case-insensitive find (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: Forse era un'idea di Roger Pate, ma non è sicuro, dato che alcuni dettagli erano un po 'spenti (std :: search ?, comparatore diretto di stringhe?)

Answer 7

Io uso il seguente:

bool str_iless(std::string const & a, 
       std::string const & b) 
{ 
    return boost::algorithm::lexicographical_compare(a, b, 
                boost::is_iless()); 
} 
std::map<std::string, std::string, 
     boost::function<bool(std::string const &, 
           std::string const &)> 
     > case_insensitive_map(&str_iless); 

Answer 8

Qui ci sono alcune altre alternative, tra cui uno che esegue molto più velocemente.

#include <map> 
#include <string> 
#include <cstring> 
#include <iostream> 
#include <boost/algorithm/string.hpp> 

using std::string; 
using std::map; 
using std::cout; 
using std::endl; 

using namespace boost::algorithm; 

// recommended in Meyers, Effective STL when internationalization and embedded 
// NULLs aren't an issue. Much faster than the STL or Boost lex versions. 
struct ciLessLibC : public std::binary_function<string, string, bool> { 
    bool operator()(const string &lhs, const string &rhs) const { 
     return strcasecmp(lhs.c_str(), rhs.c_str()) < 0 ; 
    } 
}; 

// Modification of Manuel's answer 
struct ciLessBoost : std::binary_function<std::string, std::string, bool> 
{ 
    bool operator() (const std::string & s1, const std::string & s2) const { 
     return lexicographical_compare(s1, s2, is_iless()); 
    } 
}; 

typedef map< string, int, ciLessLibC> mapLibc_t; 
typedef map< string, int, ciLessBoost> mapBoost_t; 

int main(void) { 
    mapBoost_t cisMap; // change to test other comparitor 

    cisMap["foo"] = 1; 
    cisMap["FOO"] = 2; 

    cisMap["bar"] = 3; 
    cisMap["BAR"] = 4; 

    cisMap["baz"] = 5; 
    cisMap["BAZ"] = 6; 

    cout << "foo == " << cisMap["foo"] << endl; 
    cout << "bar == " << cisMap["bar"] << endl; 
    cout << "baz == " << cisMap["baz"] << endl; 

    return 0; 
} 

Answer 9

testati:

template<typename T> 
struct ci_less:std::binary_function<T,T,bool> 
    { bool operator() (const T& s1,const T& s2) const { return boost::ilexicographical_compare(s1,s2); }}; 

... 

map<string,int,ci_less<string>> x=boost::assign::map_list_of 
     ("One",1) 
     ("Two",2) 
     ("Three",3); 

cout << x["one"] << x["TWO"] <<x["thrEE"] << endl; 

//Output: 123 

Answer 10

Per C++ 11 e oltre:

#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; 
}