是否可以使用比较器函数过滤掉 STL multiset lower_bound 检查的数据？

Question

我们使用一个 std::multiset range_type 成员变量来存储我们的 Range 数据。当我们调用

std::multiset<Range>::const_iterator iter = ranges_type.lower_bound(Range(n));
if (iter == ranges_type.end() || iter->low() > n){     
    found = false;
}
else{
    curr = *(iter);
}

ranges_type.lower_bound(Range(n)) 可以返回多个候选 Range 元素。然而，STL multiset::lower_bound(Range(n) 总是选择第一个候选元素。我们想知道是否可以使用比较器函数来控制 ranges_type.lower_type(Range(n)) 返回的候选元素。例如，假设我们只需要 caseNumber 1 或 case Number 10 的 lower_bound 答案。然后我们尝试将类 Range 运算符

bool operator<(const Range& rhs) const{
    if ((mCaseNumber == 10 || mCaseNumber == 1) &&
    (rhs.mCaseNumber == 10 || rhs.mCaseNumber == 1)){
       return mHigh < rhs.mHigh;
     }
     else {
      return false;
     }
}

不幸的是，这个原始运算符不能正常工作。 我们想知道是否可以更改比较器函数，以便 std::lower_bound 仅返回 CaseNumber 10 或 Case 1 的 Range 元素，但不返回 case 15 的 Range 元素。我们的原始类 Range 如下所示。

class Range { 
     public:   
         explicit Range(int item){
            mLow = item;
            mHigh = item;
            mPtr  = 0;
            mMapPtr = 0;
            mStamp = 0;
            mCaseNumber = 100;
            mCurrentN = 0;
         }
         Range(int low, int high, char* ptr = 0,char* mapptr = 0, int stamp = 0, 
               int casenumber = 100, int currN = 0,int currMappedLength = 0){  
            mLow = low;
            mHigh = high;
            mPtr  = ptr;
            mMapPtr = mapptr;
                           mStamp = stamp;
            mCaseNumber = casenumber;
            mCurrentN = currN;
                           mMappedLength = currMappedLength;        
         }
         Range(void){  
            mLow = 0;
            mHigh = 0;
            mPtr  = 0;
            mMapPtr = 0;
                            mStamp = 0;
            mCaseNumber = 100;
            mCurrentN = 0;
         }

         Range(const Range& r):
            mLow(r.mLow),
            mHigh(r.mHigh),
            mPtr(r.mPtr),
            mMapPtr(r.mMapPtr),
            mStamp(r.mStamp),
            mCaseNumber(r.mCaseNumber),
            mCurrentN(r.mCurrentN),
                           mMappedLength(r.mMappedLength)
         {
         }

         ~Range(){
         }  


         bool operator==(const Range& rhs) const{
             return (mLow <= rhs.mLow && mHigh >= rhs.mHigh);
         }
         bool operator<(const Range& rhs) const{
                return mHigh < rhs.mHigh;
         } 
         int low() const { return mLow; }   
         int high() const { return mHigh; }
         char* getPtr() const { return mPtr; }
         char* getMapPtr() const { return mMapPtr; }
         int getStamp() const { return mStamp; }
         int getCaseNumber() const { return mCaseNumber; }
                 int getMappedLength() const { return mMappedLength; }
     private:   
         int mLow;   
         int mHigh; 
         char* mPtr;
         char* mMapPtr;
         int mStamp;
         int mCaseNumber;
         int mCurrentN;
         int mMappedLength;
}; // class Range 

Answer 1

来自std::lower_bound's documentation，作为第三个参数传递的比较函数是：

比较函数对象， 取两个相同类型的值 比范围内的那些， 如果第一个参数返回 true 在第二个参数之前 具体严格弱排序吧 定义，否则为假。

所以，试试这样的：

bool Range::CustomComparator( const Range& lhs, const Range& rhs ){//declare it static
    //Your logic here
}

并将 Range::CustomComparator 传递给 lower_bound 调用