Realización de map :: find operación case insensible

Question

¿El mapa :: encuentra la búsqueda insensible a mayúsculas/minúsculas?
Tengo un mapa de la siguiente manera

map<string,vector<string> > directory; 

y desea que la búsqueda de abajo para ignorar caso.

directory.find(search_string); 

Answer 1

No lo hace de forma predeterminada. Deberá proporcionar un comparador personalizado como tercer argumento. Siguiente fragmento le ayudará 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 
    } 
    }; 

Se usa como std::map< std::string, std::vector<std::string>, ci_less > myMap;

NOTA: std :: lexicographical_compare tiene algunos detalles esenciales. La comparación de cadenas no siempre es sencilla si se consideran configuraciones regionales. Ver this thread en c.l.C++ si está interesado.

ACTUALIZACIÓN: Con C++ 11 std::binary_function está en desuso y no es necesario ya que los tipos se deducen automáticamente.

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, no se puede hacer que el uso de find como en ese caso habrá varias coincidencias. Por ejemplo, al insertar le permite hacer algo como map["A"] = 1 y map["a"] = 2 y ahora, si desea un caso insensible map.find("a"), ¿cuál es el valor de retorno esperado? La forma más sencilla de resolver esto sería insertar la cadena en el mapa en un solo caso (ya sea en mayúscula o minúscula) y luego usar el mismo estuche al hacer el hallazgo.

Answer 3

El elemento Comparar de la plantilla de mapa tiene como valor predeterminado una clase de comparación binaria "menos". Mira a la puesta en práctica:

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

es probable que pueda crear su propia clase que deriva de binary_function (la clase padre a menos) y hacer lo mismo sin comparación entre mayúsculas y minúsculas.

Answer 4

Pueden crearse instancias std::map con tres parámetros: tipo de llaves, el tipo de valores, y la función de comparación - una estricta débil ordenar (esencialmente, una función o un funtor comportarse como operator< en términos de transitividad y anti-reflexividad) de su agrado. Simplemente defina el tercer parámetro para hacer "insensible a mayúsculas y minúsculas que no sea" (por ejemplo, mediante un < en las cadenas minúsculas que está comparando) y tendrá el "mapa insensible a mayúsculas y minúsculas" que desee.

Answer 5

Implemente la función std :: less y compare cambiando ambas al mismo caso.

Answer 6

En caso de que no quiere tocar el tipo de mapa (para mantener su simplicidad original y eficiencia), pero no les importa usar un caso-insensibles función más lenta 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)); 
} 

PD: Tal vez fue idea de Roger Pate, pero no estoy seguro, ya que algunos detalles estaban un poco desajustados (std :: search ?, ¿comparador de cadenas directo?)

Answer 7

que utilizar los siguientes:

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

Aquí están algunas otras alternativas, incluyendo uno que lleva a cabo mucho más rápido.

#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

probados:

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

Para C++ 11 y más allá:

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