Question

我正在重构一些代码，发现有两个地方可以用相同的代码编写，除了一个集合的比较器在一个地方是less<double>而在另一个地方是greater<double>。类似的东西：

double MyClass::Function1(double val)
{
    std::set<double, less<double> > s;
    // Do something with s
}

double MyClass::Function2(double val)
{
    std::set<double, greater<double> > s;
    // Do the same thing with s as in Function1
}

所以我想到了：

double MyClass::GeneralFunction(double val, bool condition)
{  
    if(condition)  
    {  
        // Select greater as comparator  
    }  
    else
    {  
        // Select less as comparator  
    }  

    set<double, comparator> s;  
    // common code
}

我通过使用自定义比较器功能使其工作，如下所示：

bool my_greater(double lhs, double rhs)
{
    return lhs > rhs;
}

bool my_less(double lhs, double rhs)
{
    return lhs < rhs;
}

double MyClass::GeneralFunction(double val, bool condition)
{ 
    typedef bool(*Comparator) ( double,  double);
    Comparator comp = &my_less;
    if (condition)
    {
        comp = &my_greater;
    }

    std::set<double, Comparator > s(comp);  

    //....
}

但我想使用内置的。问题是我不知道如何声明比较器并为其分配内置谓词。

非常感谢任何帮助。

Answer 1

你真的需要运行时检查吗？

template <class Comp> double MyClass::Function(double val)
{
    std::set<double, Comp > s;
    // Do something with s
}

即使你这样做，你仍然可以使用

double MyClass::Function(double val, bool comp)
{
   return comp ? Function<std::less<double> >(val) : Function<std::greater<double> >(val);
}

Answer 2

问题是您无法选择比较器的类型 tuntime，std::less和std::greater具有不相关的类型。同样，std::set实例化std::less作为比较器具有与std::greater实例化无关的类型。有几种可能的解决方案，但最简单的（而且是唯一的解决方案）涉及到安装，虚拟功能和动态分配）你正在做的事情：

class SelectableCompare
{
    bool myIsGreater;
public:
    SelectableCompare( bool isGreater ) : myIsGreater( isGreater ) {}
    bool operator()( double d1, double d2 ) const
    {
        static std::less<double> const less;
        return myIsGreater
            ? less( d2, d1 )
            : less( d1, d2 );
    }
};

因为您，我使用了标准std::less和std::greater 表示有兴趣这样做。在double的情况下，这是，坦率地说，矫枉过正;我通常只会写d1 > d2和d1 < d2。一个然而，上面的模板化版本可能有意义，因为有些类型可能有专门的std::less。这也是我只使用的原因 std::less;可以想象一个程序员只专攻 std::less，知道这是唯一用过的在标准库中订购。

要完成：显而易见的替代方案是使用策略比较器中的模式，带有抽象比较器基础：

class Comparator
{
public:
    virtual ~Comparator() {}
    virtual bool isLessThan( double d1, double d2 ) const = 0;
};

，用于不同比较的相当明显的派生类，以及管理内存的包装器：

class ComparatorWrapper
{
    std::shared_ptr<Comparator> myComparator;
public:
    ComparatorWrapper( Comparator* newed_comparator )
        : myComparator( newed_comparator )
    {
    }
    bool operator()( double d1, double d2 ) const
    {
        return myComparator->isLessThan( d1, d2 );
    }
};

对于你需要的二元选择来说，这绝对有点过分，但可能会适当的，如果有更多的选择;例如可能是set 排序在许多不同领域之一（所有不同类型）。

Answer 3

只需使用

std::set<double, std::function<bool(double,double)>>

作为你的集合，并像这样实例化：

typedef std::set<double, std::function<bool(double,double)> > RTSet;

RTSet choose_ordering(bool increasing)
{
    if (increasing)
        return RTSet( std::less<double>() );
    else
        return RTSet( std::greater<double>() );
}

一般情况下，请注意您的权衡是：

检查每次比较的排序，或
在实例化时检查一次，但也在每个函数调用中产生间接（例如虚函数调用）

我更喜欢第二个选项，因此在使用集合时不会意外更改排序，从而打破其所有不变量。

只是一个简单的想法，因为这可能是一个单独的答案（甚至问题），但你提到两位代码是相同的，除了排序顺序。

我在某些情况下使用的替代方法是使用单个排序方向，并在集合上模拟代码操作（通过迭代器类型），这样就可以了

if (increasing)
    do_stuff(set.begin(), set.end());
else
    do_stuff(set.rbegin(), set.rend());

Answer 4

为什么不

template <typename Compare>
double MyClass::GeneralFunction(double val)
{
    std::set<double, Compare> s;

    //....
}

通过形式参数选择模板不是C ++处理得很好的东西。通过让调用者提供模板参数，尽可能多地进入编译阶段。

然后你可以提供一个包装器，如果你真的想在运行时选择一个：

double MyClass::GeneralFunction(double val, bool condition)
{
    return condition ?
        GeneralFunction<std::greater<double> >(val) :
        GeneralFunction<std::less   <double> >(val);\
}

std :: set在运行时选择更少或更大的比较器

4 个答案: