Delegierten std :: weniger oder std :: mehr in Bedingung

Question

Ich habe bereits einen Testfall implementiert, wo ich Schlüssel als eigene Klasse haben können wie folgt:

#include <iostream> 
#include <map> 

using namespace std; 

class CoordinateValue 
{ 
public: 

    short int x_; 
    short int y_; 

    CoordinateValue(short int x = 0, short int y = 0) 
    : x_(x),y_(y) 
    { 

    } 

    bool operator<=(const CoordinateValue &right) const 
    { 
     return ((this->x_ <= right.x_) && (this->y_ <= right.y_)); 
    } 

    bool operator<(const CoordinateValue &right) const 
    { 
     return ((this->x_ < right.x_) && (this->y_ < right.y_)); 
    } 

    bool operator>=(const CoordinateValue &right) const 
    { 
     return ((this->x_ >= right.x_) && (this->y_ >= right.y_)); 
    } 

    bool operator>(const CoordinateValue &right) const 
    { 
     return ((this->x_ > right.x_) && (this->y_ > right.y_)); 
    } 


    friend ostream &operator<<(ostream &out, const CoordinateValue &val) 
    { 
     out << "[ " << val.x_ << "," << val.y_ << " ]" << std::endl; 

     return out; 
    } 
} ; 

int main() 
{ 

    std::multimap<CoordinateValue,int,std::less_equal<CoordinateValue>> intersectionIn; 


    intersectionIn.insert(std::pair<CoordinateValue,int>(CoordinateValue(100,200),12)); 
    intersectionIn.insert(std::pair<CoordinateValue,int>(CoordinateValue(1000,7),135)); 
    intersectionIn.insert(std::pair<CoordinateValue,int>(CoordinateValue(0,2),112)); 
    intersectionIn.insert(std::pair<CoordinateValue,int>(CoordinateValue(-10,-200),12)); 
    intersectionIn.insert(std::pair<CoordinateValue,int>(CoordinateValue(-100,-200),12)); 
    intersectionIn.insert(std::pair<CoordinateValue,int>(CoordinateValue(1000,2000),12)); 

    std::multimap<CoordinateValue,int,std::greater<CoordinateValue>>::const_iterator iter = intersectionIn.begin(); 

    while(iter != intersectionIn.end()) 
    { 
     std::cout << iter->first; 
     ++iter; 
    } 

    return 0; 
} 

Jetzt möchte ich nennen std :: größer/std :: less/std :: less_equal basierend auf einer Bedingung. Wie delegiere ich? Für eine Bedingung deklariere ich zum Beispiel den Container mit std :: less und für andere Bedingungen deklariere ich den Container mit std :: large.

Einige Hinweis oder Referenz wäre großartig zu haben.

Dank

Answer 1

Es sieht aus wie Sie eine Laufzeitversion (von Ihren Kommentar) möchten, können Sie den Typ std::function<bool(int, int)> als Compare Typ in multimap verwenden können und dann entweder speichern std::less oder std::greater wenn die Karte zu erstellen:

std::function<bool(int, int)> cmp; 
if (...) { 
    cmp = std::less<int>(); 
} 
else { 
    cmp = std::greater<int>(); 
} 
std::multimap<int, int, decltype(cmp)> map(cmp); 

-Code auf ideone: http://ideone.com/cP0OEm

---

Old Kompilierung Version unter:

Wenn Sie c++11 verwenden können, Sie std::conditional verwenden:

template <typename T> 
using cmp = typename std::conditional<cond, std::greater<T>, std::less<T>>::type; 

Wo cond Ihr Zustand ist, und Sie können Kette std::conditional für mehrere Bedingungen.

Und dann:

std::multimap<int, int, cmp<int>> map; 

Da Sie nicht sagen, was Ihre Bedingungen waren, kann ich nicht mehr Informationen hinzufügen.

Nachdem Sie Ihren Kommentar, dies könnte wie folgt aussehen:

template <int value, typename T> 
using cmp = typename std::conditional<(value > 0), std::less<T>, std::greater<T>>::type; 

std::multimap<int, int, cmp<MY_VALUE, int>> map; 

Wo MY_VALUE eine Kompilierung konstant ist.