レンジキーで値を保持する構造

Question

範囲を持つキーに基づいて値を保持する構造体が必要です。 私の実装はC++なので、STLやBoostは優れています。

私はダブルスある範囲キー、および値

• [0,2）として持っている - >値1
• は、[2,5） - >値2
• [5,10） - > VALUE3
• など

1.23の検索がようにVALUE1を返す、とすべきであることをこのような。

今私は、key1/key2/valueの3つの部分すべてを含むベクトルをカスタム検索で使用していますが、よりクリーンな構造が必要なように感じます。

編集：ありがとうございます。この場合の範囲が連続していてオーバーラップしていないと仮定すると、upper_boundの使用はうまく動作します。クラスのソリューションのおかげで、彼らは将来の参照のために離れて提出されます。

Answer 1

範囲が連続して重複していない場合は、std :: mapとupper_boundメンバー関数を使用する必要があります。または、ソートされたベクトルをupper_boundアルゴリズムで使用することもできます。いずれにしても、範囲の最低値を記録するだけで、範囲の上位部分は次の高い値で定義されます。

編集：私はそれを混乱させると言いましたので、私は例を挙げることにしました。例のコーディングでは、lower_boundの代わりにupper_boundが必要であることに気付きました。私はいつもそれら2つを混乱させます。

typedef std::map<double, double> MyMap; 
MyMap lookup; 
lookup.insert(std::make_pair(0.0, dummy_value)); 
lookup.insert(std::make_pair(2.0, value1)); 
lookup.insert(std::make_pair(5.0, value2)); 
lookup.insert(std::make_pair(10.0, value3)); 
MyMap::iterator p = lookup.upper_bound(1.23); 
if (p == lookup.begin() || p == lookup.end()) 
    ...; // out of bounds 
assert(p->second == value1); 

Answer 2

class Range 
{ 
public: 
    Range(double a, double b): 
     a_(a), b_(b){} 
    bool operator < (const Range& rhs) const 
    { 
     return a_ < rhs.a_ && b_ < rhs.b_; 
    } 
private: 
    double a_; 
    double b_; 
}; 
int main() 
{ 
    typedef std::map<Range, double> Ranges; 
    Ranges r; 

    r[ Range(0, 2) ] = 1; 
    r[ Range(2, 5) ] = 2; 
    r[ Range(5, 10) ] = 3; 

    Ranges::const_iterator it1 = r.find(Range(2, 2)); 
    std::cout << it1->second; 

    Ranges::const_iterator it2 = r.find(Range(2, 3)); 
    std::cout << it2->second; 

    Ranges::const_iterator it3 = r.find(Range(6, 6)); 
    std::cout << it3->second; 

    return 0; 
} 

Answer 3

どのようにこれらの線に沿って何かについて：

#include "stdafx.h" 
#include <iostream> 
#include <string> 
#include <map> 
#include <algorithm> 
#include <sstream> 


class Range 
{ 
public: 
    Range(double lower, double upper) : lower_(lower), upper_(upper) {}; 
    Range(const Range& rhs) : lower_(rhs.lower_), upper_(rhs.upper_) {}; 
    explicit Range(const double & point) : lower_(point), upper_(point) {}; 
    Range& operator=(const Range& rhs) 
    { 
     lower_ = rhs.lower_; 
     upper_ = rhs.upper_; 
     return * this; 
    } 

    bool operator < (const Range& rhs) const 
    { 
     return upper_ <= rhs.lower_; 
    } 

    double lower_, upper_; 
}; 

typedef std::string Thing; 
typedef std::map<Range, Thing> Things; 


std::string dump(const std::pair<Range,Thing> & p) 
{ 
    stringstream ss; 
    ss << "[" << p.first.lower_ << ", " << p.first.upper_ << ") = '" << p.second << "'" << endl; 
    return ss.str(); 
} 

int main() 
{ 
    Things things; 
    things.insert(std::make_pair(Range(0.0, 5.0), "First")); 
    things.insert(std::make_pair(Range(5.0, 10.0), "Second")); 
    things.insert(std::make_pair(Range(10.0, 15.0), "Third")); 

    transform(things.begin(), things.end(), ostream_iterator<string> (cout,""), dump); 

    cout << "--------------------------------------" << endl; 

    things[Range(1.5)] = "Revised First"; 

    transform(things.begin(), things.end(), ostream_iterator<string> (cout,""), dump); 


    return 0; 
} 

...プログラムの出力：

[0, 5) = 'First' 
[5, 10) = 'Second' 
[10, 15) = 'Third' 
-------------------------------------- 
[0, 5) = 'Revised First' 
[5, 10) = 'Second' 
[10, 15) = 'Third'