在模板类中使用 STL 算法（特别是 std::sort）

Question

我已经声明了一个模板类 MyContainer，如下所示，然后创建了它的 DataType1 类型的实例。 DataType1 类提供了一个友元函数“DataSpecificComparison”，std::sort 使用它来比较 DataType1 对象。程序已正确编译和排序。

然后，我定义了一个名为 DataType2 的类，为其提供了“DataSpecificComparison”的友元实现，并使用它创建了 MyContainer 的另一个实例。

我现在无法编译程序，因为报告了“C2914: 'std::sort': 无法推断模板参数，因为函数参数不明确”编译时错误。

开发人员如何指定 DataSpecificComparison 二进制谓词采用模板类型 T* 的参数？或者还有其他方法可以解决这个问题吗？

template <class T>
class MyContainer
{
private: 
    vector<T*> m_vMyContainerObjects;
    ....

public:
    ....
    void SortMyContainerObjects()
    {
        std::sort(m_vMyContainerObjects.begin(), m_vMyContainerObjects.end(), DataSpecificComparison)
    }
}


class DataType1
{
    ....
    friend bool DataSpecificComparison(const DataType1 * lhs, const DataType1 * rhs)
}

class DataType2
{
    ....
    friend bool DataSpecificComparison(const DataType2* lhs, const DataType2* rhs)
}

Answer 1

您可以使用所需类型的临时本地函数指针变量来选择 DataSpecificComparison 的正确重载：

void SortMyContainerObjects()
{
    typedef bool (*comparer_t)(const T*, const T*);
    comparer_t cmp = &DataSpecificComparison;
    std::sort(m_vMyContainerObjects.begin(), m_vMyContainerObjects.end(), cmp);
}

这里编译器可以推断出您想要使用匹配的 DataSpecificComparison 重载comparer_t 类型，它解决了歧义。

Answer 2

sth 已经给出了正确的答案，但还有一个基于相同原理的直接替代方案：

void SortMyContainerObjects()
{

    std::sort(m_vMyContainerObjects.begin(), m_vMyContainerObjects.end(),
       static_cast<bool (*comparer_t)(const T*, const T*)>(&DataSpecificComparison));
}

这基本上使用相同的机制。强制转换强制重载决策在 std::sort 的模板参数推导之前发生。

Answer 3

template<typename T>
struct DataSpecificComp : public binary_function<T, T, bool>
{
public:
    bool operator()(const T* lhs, const T* rhs)
    {
        return *lhs < *rhs;
    }
};

调用排序函数如下所示：

sort(vi.begin(), vi.end(), DataSpecificComp<int>());

Answer 4

我更喜欢以下内容：默认情况下，它将对象与 less_than 进行比较（这样您就不必记住提供一个具有有趣名称的函数），并且有一个重载允许给出你自己的比较函子（同样，基于值）：

#include <vector>
#include <algorithm>
#include <functional>

template <class T, class Func>
struct indirect_binary_call_type: public std::binary_function<const T*, const T*, bool>
{
    Func f;
    indirect_binary_call_type(Func f): f(f) {}
    bool operator()(const T* a, const T* b) const
    {
        return f(*a, *b); 
    } 
};

template <class T, class Func>
indirect_binary_call_type<T, Func> indirect_binary_call(Func f)
{
    return indirect_binary_call_type<T, Func>(f);
}

template <class T>
class MyContainer
{
private: 
    std::vector<T*> m_vMyContainerObjects;

public:
    void Sort()
    {
        Sort(std::less<T>());
    }
    template <class Func>
    void Sort(Func f )
    {
        std::sort(m_vMyContainerObjects.begin(), m_vMyContainerObjects.end(), indirect_binary_call<T>(f));
    }

};

int main()
{
    MyContainer<int> m;
    m.Sort();
    m.Sort(std::greater<int>());
}

Answer 5

您是否尝试将 DataSpecificComparison 定义为具有一堆专业化的模板并为其指定类型？

template<T>
bool DataSpecificComparison(const T* t1, const T* t2)
{
    // something non compilable here
}

template<> bool DataSpecificComparison<Data1>(const Data1* t1, const Data1* t2)
{
    // return *t1 < *t2;
}

....
void SortMyContainerObjects()
{
    std::sort(m_vMyContainerObjects.begin(), m_vMyContainerObjects.end(), DataSpecificComparison<T>)
}
....

Answer 6

模板化 DataSpecificComparison 应该可以工作。您还可以专门调用适当的 std::sort 模板，但这有点麻烦：

template <class T>
class MyContainer
{
private: 
    vector<T*> m_vMyContainerObjects;
    typedef bool (*compsT)(T, T); 

public:
    ....
    void SortMyContainerObjects()
    {
        std::sort<std::vector<T*>::iterator, compsT>(m_vMyContainerObjects.begin(), m_vMyContainerObjects.end(), DataSpecificComparison);
    }
}