标准::地图<tuple<int,int> .lower_bound/upper_bound 前缀搜索没有找到后缀的最小/最大元素

Question

I am building a class which uses a std::map<tuple<...>> as a lookup data structure. I want to be able to do a prefix search on the map to find all elements sharing a certain prefix inside the tuple. For instance:

using namespace std;
map<tuple<int,int,int,string>,Value> index;
index.insert(make_tuple(1,1,1,"a"),Value());
index.insert(make_tuple(1,1,2,"b"),Value());
index.lower_bound(make_tuple(1,1,std::numeric_limits<int>::min(),""));

This does exactly what I need but I have to manually (for non POD types) figure out the minimum value. Even worse, when I want to find the highest element with a certain prefix (which I do), I would have to find the maximum element value for a certain type, which in case of string is rather problematic.

Ideally, I would be able to supply map.find/lower_bound/upper_bound (not std::find which is linear complexity on maps) with a separate comparison which does not take the suffix into account but unfortunately this is not possible, most likely because prefix search is more or less the only sensible application.

I think options would be modifying the comparison used by map at runtime (which I consider extremely bad style) or implementing a numeric_limits equivalent for all types I will have inside of tuples.

Is there a better option out there for doing a prefix search on a map/set?

Answer 1

You get to pass in a "static" comparison functor to the map when you define it. The default ordering on tuple<...> is a lexicographic ordering on the type.

Extend the key type to ones that allow for fields to be flagged as max or min values, and provide a sorting algorithm that accepts them.

ie, something like this:

template<typename T>
struct InfiniteExtensionOf
{
  enum ExtendedOrder {NegInfinity=-1, Normal=0, PosInfinity=1};
  ExtendedOrder order;
  T value;
  bool operator<(InfiniteExtensionOf const& other) const
  {
    if (order != other.order)
      return order<other.order;
    return value < other.value;
  }
  template<typename U>
  InfiniteExtensionOf( U&& u ):order(Normal),value(std::forward(u)) {}
  InfiniteExtensionOf( InfiniteExtensionOf&& other ):order(other.order),value(std::move(other.value)) {}
  InfiniteExtensionOf( InfiniteExtensionOf& other ):order(other.order),value(other.value) {}
  InfiniteExtensionOf( InfiniteExtensionOf const& other ):order(other.order),value(other.value) {}
  InfiniteExtensionOf( ExtendedOrder& eo ):order(eo), value() {}
  InfiniteExtensionOf( ExtendedOrder&& eo ):order(eo), value() {}
  InfiniteExtensionOf( ExtendedOrder const& eo ):order(eo), value() {}
};

then key like this:

map<tuple<InfiniteExtensionOf<int>, InfiniteExtensionOf<int>, InfiniteExtensionOf<int>, InfiniteExtensionOf<string>>, Value> myMap;

which should accept tuple s without the InfiniteExtensionOf argument (as such tuples implicitly convert, I hope), and you can specify +inf or -inf as the value of a particular field easily when calling lower_bound or upper_bound .

...

Note that if lower_bound took a template argument and only required it to be compatible to elements in the map in a way that agreed with the existing ordering, this would be less hassle. :) But sadly, that isn't true.

Answer 2

What you could do is not using the key types directly but sort of a tristate version of an optional type:

1. If the value is set, the comparison just uses the value.
2. If the small flag is set the value is thought to be smaller than all other values.
3. If the large flag is set the value is thought of being larger than any other value.

To find the lower bound you would then search, eg, using the small value:

map.lower_bound(srd::make_tuple(
    tristate<int>(17),
    tristate<std::string>(tristate_small)));

This is for a map having a key made up of an int and a std::string , each one potentially replaced by a small or a large value.