how does count in c++ stl set work?

Question

So, I'm trying to check whether a particular object is already present in the set. For this, I use the count() method. Now, it doesn't seem to return the right answer. Let me explain the problem a bit more clearly --

I have declared a class this way

class Node{
        public:
                Node(int _state=0, int _cost=0)
                {
                        state = _state;
                        cost = _cost;
                }

                bool operator<(const Node& rhs)
                {
                        return cost < rhs.cost;
                }

                bool operator==(const Node& rhs)
                {
                        cout << "== operator method used" << endl;
                        if (rhs.state == state)
                                return true;
                        return false;
                }

                int state;
                int cost;
};

in my code, I declare a set like this --

set<Node*> myset;

after a few insertions, myset is like this {{1, 5}, {2, 6}, {3, 9}}

now I check whether {1, 7} is part of the set. How would it do it? I have written a operator== method in Node class, which is never called. Then on what basis does count() check if the object is already in the set?... I would want the count to work in a fashion that if {1, 5} is already there in myset, it should view {1, 7} as a duplicate entry.

score 7 · Accepted Answer · answered Nov 14 '11 at 06:49

7

how does count in c++ stl set work?

It uses operator< by default.

In fact, in general, C++ Standard Library containers use !(a < b) && !(b < a) to determine the property of equivalence.

You can override the comparator used to perform this check by providing your own Compare template argument to the container type, though there is rarely a reason to — you should usually simply define operator< for your type instead, as you have done. (Make sure that it creates a Strict Weak Ordering, though.)

in my code, I declare a set like this --
set<Node*> myset;
after a few insertions, myset is like this {{1, 5}, {2, 6}, {3, 9}}

No, your set is never like this. Your set contains pointers, not Nodes. Make it a set<Node> instead.

answered Nov 14 '11 at 06:49

Lightness Races in Orbit

378,754
76
643
1,055

i want my ordering to be w.r.t to cost variable, but my duplicate element resolution to be w.r.t to state variable... How can I do such a thing in the operator< method? I tried putting a cout statement in the operator< method and that doesn't seem to work either... thanks! – shashydhar Nov 14 '11 at 06:56
@shashydhar: Don't do that. That sort of approach is going to result in undefined behaviour, because it's contrary to how the container works. You define the ordering; once it's a valid ordering, the container takes care of checking for dups. If it can't do that, then your ordering is not valid. – Lightness Races in Orbit Nov 14 '11 at 06:57
ok, thanks. I'll try to look at the ordering thing once again. – shashydhar Nov 14 '11 at 07:02

score 1 · Answer 2 · answered Nov 14 '11 at 07:08

STL does not use == operator for comparison, it uses < operator by default and it suffices, because a != b <=> a<b or b<a. You defined a set of pointers to Node. So your set does not behave the way you want. You should define set<Node>. and also its important to note that STL uses < for both insertion and find (i.e. count function uses <), so you can not use comparison based on cost for insertion and comparison based on state for finding (your code is like this!).

Avinash · Answer 3 · 2011-11-14T07:04:23.093

Thi is the typical example how you would you use std::set to find the element exists or not

#include <iostream>
#include <set>

int main(){
    std::set<int> mySet;
    mySet.insert(1);
    mySet.insert(2);
    mySet.insert(3);
    mySet.insert(4);
    mySet.insert(5);

    std::set<int>::iterator pos;
    pos = mySet.find(5);

    if ( pos == mySet.end()){
        std::cout << "Not Found" << std::endl;
    }
}

Complete example is as follows:

#include <iostream>
#include <set>

class Node {
public:
    Node(int _state =0, int _cost =0) : state(_state),cost(_cost) {}

    bool operator < (const Node& rhs) const {
        return cost < rhs.cost;
    }
private:
    int state;
    int cost;
};

int main(){
    std::set<Node> myset;
    myset.insert(Node(1,5));
    myset.insert(Node(2,6));
    myset.insert(Node(3,9));

    std::set<Node>::iterator pos, pos1;
    pos = myset.find(Node(1,5));
    pos1 = myset.find(Node(1,7));

    if ( pos == myset.end()){
        std::cout << "Not Found" << std::endl;
    } else {
        std::cout << "Found" << std::endl;
    }
    if ( pos1 == myset.end()){
        std::cout << "Not Found" << std::endl;
    } else {
        std::cout << "Found" << std::endl;
    }

}

score 0 · Answer 4 · answered Nov 14 '11 at 06:50

0

If you see for example this reference page, you see that there is a template parameter Compare. You have to implement your own comparison function.

answered Nov 14 '11 at 06:50

Some programmer dude

400,186
35
402
621

score 0 · Answer 5 · answered Nov 14 '11 at 06:55

It doesn't work because you declared a ser of pointers so that is what the container will compare.

Your comparison method < is not going to be used because std::set will use standard comparison between pointers. You will also find duplicates in your set if two Nodes have the same contente but a different address.

score -2 · Answer 6 · edited Nov 14 '11 at 06:54

-2

set<Node*> myset;

This is set of pointers; it calls operator== for pointers, not for Node.

You should use std::set<Node> if you want to see call of Node::operator==.

edited Nov 14 '11 at 06:54

Lightness Races in Orbit

378,754
76
643
1,055

answered Nov 14 '11 at 06:51

fghj

8,898
4
28
56

1

No, it doesn't use `operator==`. – Lightness Races in Orbit Nov 14 '11 at 06:52
1

Any way it not calls Node::operator< for std::set – fghj Nov 14 '11 at 06:53

how does count in c++ stl set work?

6 Answers6