Re: Finding an int key less than or equal to

DerekBaker wrote:


a "map of int." A map is formed using key/value (or rather, key/mapped type)
pairs. Are the keys ints, the corresponding mapped values, or both?

Given this uncertainty on my part, the following is at least a compilable
example that presents one idea for finding keys that are less than a given
'value' (in the general sense) that may not be present in the map. It uses a
map<int, string> by way of example, and may or may not be helpful to you in
illustrating the kinds of things that are possible using the STL alone, which is
what you are specifically asking. It finds all the mapped values corresponding
to keys (int) that are less than 6 (which is not present as a key in the map).

    #include <iostream>
    #include <map>
    #include <string>
    #include <algorithm>
    #include <functional>

    int main()
    {
       std::map<int, std::string> odds;

       odds[1] = "one";
       odds[3] = "three";
       odds[5] = "five";
       odds[7] = "seven";
       odds[9] = "nine";

       std::map<int, std::string>::iterator map_iter =
          std::find_if(
                    odds.begin(),
                    odds.end(),
                    std::bind2nd(std::less<std::pair<int, std::string> >(),
                                 std::make_pair(6, ""))
                   );
       while (map_iter != odds.end())
       {
          std::cout << map_iter->second << '\n';
          map_iter = std::find_if(
                    ++map_iter,
                    odds.end(),
                    std::bind2nd(std::less<std::pair<int, std::string> >(),
                                 std::make_pair(6, ""))
                   );
       }

       return 0;
    }

Output:
         one
         three
         five

Better, however, would be to avoid the awkwardness in the above example of
having to compare /pairs/ through providing your own functor, allowing
comparison of keys directly. You might define this as something like:

    template<typename Key, typename Value>
    class key_less_than {
    public:
       explicit key_less_than(Key key_comp)
          : key_comp_(key_comp)
       { }
       bool operator()(const typename std::map<Key, Value>::value_type& key_val)
       {
          return key_val.first < key_comp_;
       }
    private:
       Key key_comp_;
    };

and use it as:

    std::map<int, std::string>::iterator map_iter =
       std::find_if(odds.begin(),
                    odds.end(),
                    key_less_than<int, std::string>(6));

Regards

Paul Bibbings

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]