双图插入问题

Question

我有一个 stl::map 将键定义为我定义的对象，并且 int.地图的使用如下： 我有一个特定对象的列表，我想计算我有多少相同的对象。所以我将对象插入到地图中。如果对象已经存在于地图中，我会增加它的值（因此是计数器）。该对象定义了所有基本运算符。该对象由 5 个字符串组成。 == 运算符定义为所有 5 个字符串的比较，并且在逻辑上在上下文中是有意义的。问题是运算符

class Example
{
private:
    string one;
    string two;
    string three;
    string four;
    string five;
public:
    inline Example (string a_one,string a_two, string a_four, string a_five) :
        one(a_one),two(a_two),three(a_three),four(a_four),five(a_five)
        {}

    inline bool operator == (const Example& other) const
    {
        if (one == other.one)
        {
            if (two == other.two)
            {
                if (three == other.three)
                {
                    if (four == other.four)
                    {
                        if (five == other.five)
                        {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    inline bool operator < (const Example& other) const
    {
        if (one < other.one)
        {
            return true;
        }
        else if (two < other.two)
        {
            return true;
        }
        else if (three < other.three)
        {
            return true ;
        }
        else if (four < other.four)
        {
            return true;
        }
        else if (five < other.five)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

void CountExample(Example& example,std::map<Example,int>& counters);

void main()
{
    std::map<Example,int> counters;
    std::list<Example> examples = GetExamples();
    //GetExamples defined elsewhere, and initializes examples with a long list of instances of Example
    std::list<Example>::const_iterator Iter;
    for (Iter = examples.begin();Iter != examples.end();Iter++)
    {
        CountExample(*Iter);
    }
    PrintCounters(counters);//PrintCounters defined elsewhere and prints the map to a file
}

void CountExample(Example& example,std::map<Example,int>& counters)
{
    std::map<Example,int>::const_iterator Iter;
    Iter = counters.find(example);
    if (Iter ==counters.end()) //means the specific Example is not in the map
    {
        counters.insert(std::pair<Example,int>(example,1));
    }
    else
    {
        counters[example] += 1;
    {
}

Answer 1

如果您有一个相当现代的编译器，则可以用两个 std::tie()'d 元组之间的单个比较来代替比较阶梯：

#include <tuple>
...
bool operator== (const Example& other) const
{
    return std::tie(one, two, three, four, five)
        == std::tie(other.one, other.two, other.three, other.four, other.five);
}
bool operator < (const Example& other) const
{
    return std::tie(one, two, three, four, five)
         < std::tie(other.one, other.two, other.three, other.four, other.five);
}

顺便说一句，使用std::multiset 来计算特定元素存储在关联容器中的次数可能更简单，这将CountExample 简化为单行

void CountExample(const Example& example, std::multiset<Example>& counters)
{
    counters.insert(example);
}

虽然打印变得有点棘手：

void PrintCounters(const std::multiset<Example>& counters)
{
    for(auto i=counters.begin(); i!=counters.end(); i = counters.upper_bound(*i))
            std::cout << *i << ":" << counters.count(*i) << '\n';
}

在ideone上测试：http://ideone.com/uA7ao

Answer 2

要与多个元素进行比较，您比较的每个元素都会有三个结果：小于、大于或等效。您必须考虑所有这些情况。

bool LessThan(const MyClass & left, const MyClass right)
{
    if (left.one < right.one)
        return true;
    else if (right.one < left.one)
        return false;
    // equivalent in one
    if (left.two < right.two)
        return true;
    else if (right.two < left.two)
        return false;
    // equivalent in one and two
        ...
    return false;
}

Answer 3

您需要为您的输入提供operator<。这写起来可能很乏味，但您可以使用 Boost.Tuple 来简单地完成它 - 这样，元组会处理比较，让您的代码更易于阅读、编写和理解。

#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <string>

struct Object
{
    std::string a;
    std::string b;
    std::string c;
};

bool operator<(const Object& obj1, const Object& obj2)
{
    return (boost::tie(obj1.a, obj1.b, obj1.c) < 
        boost::tie(obj2.a, obj2.b, obj2.c));
}

Answer 4

编辑：在考虑了更多问题之后，我决定删除我的旧答案，因为它似乎与当前遇到的问题无关。您的 operator< 方法似乎确实满足了严格弱排序的要求，所以我认为问题出在其他地方，所以我将下面的替代解决方案留在下面......

您似乎在为地图创建总顺序时遇到问题，因此您可能希望查看std::unordered_map 作为替代方案，它会直接应用您的operator== 来检测相等性，而不是使用您的operator<对于严格的弱排序...你必须为你的类提供一个散列函数，否则使用基于散列表的 std::unordered_map 容器非常简单。