tags:

views:

885

answers:

8

Does the map::find method support case insensitive search?
I have a map as follows

map<string,vector<string> > directory;

and want the below search to ignore case.

directory.find(search_string);
+1  A: 

No, you can not do that using find as in that case there will be multiple matches. For example, while inserting lets you have done something like map["A"] = 1 and map["a"] = 2 and now if you want a case insensitive map.find("a") what is the expected return value? The simplest way to solve this would be insert the string into map in only one case (either upper or lower case) and then using the same case while doing the find.

Naveen
-1, misleading. The expected value for a case-insensitive map would simply be 2 (last value written for A"=="a") . Maps use strict weak orderings, which (can) have equivalent keys. Any such key can be used interchangably.
MSalters
may be misleading..what I was trying to show was that if you have a case sensitive map there is no way to have a find() function which works in case insensitive manner.
Naveen
Fair point, but that point would have been a lot clearer. E.g. if you had explained that `std::map` supports but a single index, which can be either case-sensitive of case-insensitive but not both. From there it's an easy link to `boost::multi_index`, which does support a second index.
MSalters
@Naveen: If he creates the map with a case insensitive comparator as Abhay suggests then he can use the member version of find for case insensitive find.
Robert S. Barnes
A: 

The Compare element of the map template defaults to a binary comparison class "less". Look at the implementation:

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

You can likely create your own class that derives from binary_function (the parent class to less) and do the same comparison without case sensitivity.

Nathan
+13  A: 

It does not by default. You will have to provide a custom comparator as a third argument. Following snippet will help you...

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

Use it like std::map< std::string, std::vector<std::string>, ci_less > myMap;

NOTE: std::lexicographical_compare has some nitty-gritty details. String comparison isn't always straightforward if you consider locales. See this thread on c.l.c++ if interested.

HTH,

Abhay
@Abhay. Thanks for your answer. However, I'm not entirely sure how does this actually work (being relatively new to STL). How does defining a third parameter, which being a comparison function or function object doing "case-insensitive" less-than, actually does case-insensitive comparison. Shouldn't we be using == operator instead. How does this actually work. I'm sure I'm mising something.
Ankur
Abhay
@Ankur: Also, as per std::map's signature std::map<Key, Data, Compare,Alloc>, 'Compare' is a 'Strict Weak Ordering' whose argument type is Key. And the tree is built using this ordering. To see what exactly is strict-weak-ordering in mathematical terms, read this simplified SGI write-up @ http://www.sgi.com/tech/stl/StrictWeakOrdering.html
Abhay
One more question, why do derive these function objects from binary_function. Yes its a base class for standard binary function objects, but what purpose does it solve here and in general?
Ankur
@Ankur: For a beginner, an easy way to remember the function objects is "The STL algorithms call a function-pointer with parameters which are values represented by the container on which the algorithm runs". They are a little versatile than plain function-pointers as they a class-type(they can store state). Now the number of parameters used to call depends on the algorithm used. I think if you can google on std::binary_function, u will find a much more detailed and technically accurate explanation which is a must read before playing with STL.
Abhay
Straight out of Meyers, "Effective STL" :)
Robert S. Barnes
+1  A: 

You can instantiate std::map with three parameters: type of keys, type of values, and comparison function -- a strict weak ordering (essentially, a function or functor behaving like operator< in terms of transitivity and anti-reflexivity) of your liking. Just define the third parameter to do "case-insensitive less-than" (e.g. by a < on the lowercased strings it's comparing) and you'll have the "case-insensitive map" you desire!

Alex Martelli
A: 

Implement std::less function and compare by changing both to same case.

Vivek
A: 

In case you don't want to touch the map type (to keep it's original simplicity and efficiency), but don't mind using a slower case-insensitive find function (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: Maybe it was Roger Pate's idea, but not sure, since some details were a bit off (std::search?, direct string comparator?)

Alink
+2  A: 

I use the following:

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);
Manuel
+1 For coolness, but wow, that's ugly. Make it a functor like in my example and typedef the map.
Robert S. Barnes
+1  A: 

Here are some other alternatives, including one which performs significantly faster.

#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 ? 1 : 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;
}
Robert S. Barnes