c++设置容器的问题

2022-01-07 00:00:00 set c++ stl

当我尝试编译以下代码时:

When I try to compile the following code:

    #include <iostream>
    #include <set>
    #include <vector>

    using namespace std;

    template <class T, class S> 
    class Property
    {
    public:
        pair<T,S> p;

        Property(T t, S s) { p = make_pair(t,s);}

    };

    int main()
    {
    set< Property<string, string> > properties;
    Property<string, string> name("name", "Andy");

    properties.insert(name);

    }

我收到编译错误.但是，当我用向量替换 set 并因此使用 push_back 函数而不是插入函数时，一切正常.谁能解释一下我做错了什么?谢谢指教.

I get the compilation error. However, when I replace set by vector and hence use the the push_back function instead of insert function everything works fine. Could anyone explain me what am I doing wrong? Thanks in advice.

推荐答案

std::set 将其值存储在已排序的二叉树中，因此它需要知道如何比较它所保存的值.默认情况下，它使用 std::less作为比较函数，对于非专业化的用户定义类型，它尝试调用 operator<.因此，告诉集合如何比较您的对象的最简单方法是为您的类定义一个 operator<:

std::set stores its values in a sorted binary tree, so it needs to know how to compare the values it holds. By default it uses std::less as a comparison function, which for un-specialized user defined types tries to call operator<. So, the easiest way to tell the set how to compare your objects is to define an operator< for your class:

template <class T, class S> 
class Property
{
public:
    pair<T,S> p;

    Property(T t, S s) { p = make_pair(t,s);}

    bool operator<(const Property<T,S>& rhs) const
    {
        return p < rhs.p;
    }
};

然而，还有其他方法可以告诉 std::set 如何比较您的类型.一种是为您的类专门化 std::less 模板:

However, there are also other ways of telling std::set how to compare your type. One is to specialize the std::less template for your class:

namespace std {
template<typename T,typename S>
struct less<Property<T, S> >
{
    bool operator()(const Property<T, S>& lhs, const Property<T,S>& rhs) const
    {
        return lhs.p < rhs.p;
    }
};
}

另一种方法是用具有正确签名的函数或具有使用正确签名定义的 operator() 的类替换默认比较类型.这就是事情开始变得丑陋的地方.

Another is to replace the default comparison type with a function with the correct signature, or a class that has an operator() defined with the correct signature. This is where things start to get ugly.

// Comparison function
template<typename T, typename S>
bool property_less_function(const Property<T,S>& lhs, const Property<T,S>& rhs)
{
    return lhs.p < rhs.p;
}

// Comparison functor
template<typename T, typename S>
struct PropertyLess
{
    bool operator()(const Property<T,S>& lhs, const Property<T,S>& rhs) const
    {
        return lhs.p < rhs.p;
    }
};

int main()
{
    // Set using comparison function. 
    // Have to pass the function pointer in the constructor so it knows
    // which function to call. The syntax could be cleaned up with some
    // typedefs.
    std::set<Property<std::string, std::string>, 
        bool(*)(const Property<std::string, std::string>&, 
                const Property<std::string, std::string>&)> 
            set1(&property_less_function<std::string, std::string>);

    // Set using comparison functor. Don't have to pass a value for the functor
    // because it will be default constructed.
    std::set<Property<std::string, std::string>, PropertyLess<std::string, std::string> > set2;
}

请记住，无论您使用什么小于函数，该函数都必须定义一个严格弱排序 适合您的类型.

Keep in mind that whatever less-than function you use, that function must define a strict weak ordering for your type.

相关文章