Question

why i need to use the const function in the less traits?
for example, why i must use const in Age or ID member function.

    #include <iostream>
#include <iterator>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
using namespace std;
class Person
{
public:
    Person(int id, string name, int age):m_iID(id), m_strName(name), m_iAge(age){};
    int Age() const {return m_iAge;}
    int ID() const {return m_iID;}
    void Display();
    friend ostream& operator<<(ostream& out, Person& person);
private:
    int m_iID;
    string m_strName;
    int m_iAge;

};
void Person::Display()
{
    cout<<m_iID<<" "<<m_strName<<" "<<m_iAge<<endl;
}
ostream& operator<< (ostream& out, Person& person)
{
    out<<person.m_iID<<" "<<person.m_strName<<" "<<person.m_iAge<<endl;
    return out;
}

int SumPersonAge(int iSumAge, Person& person)
{
    return iSumAge + person.Age();
}
template <typename Type>
void Display(Type t1)
{
    cout<<t1<<endl;
}

class LessPerson
{
public:
    template <typename Type>
    bool operator()(Type& t1, Type& t2)
    {
        return t1.ID() < t2.ID();
    }
};

int main()
{
    set<Person, LessPerson> s1;
    Person p1(1234, "Roger", 23);
    Person p2(1235, "Razor", 24);
    s1.insert(p1);
    s1.insert(p2);
    for_each(s1.begin(), s1.end(), Display<Person>);
}

if i remove the const the keyword in Age or ID function, the compiler will report me Error cannot convert ‘this’ pointer from ‘const Person’ to ‘Person &’.

Answer 1

The answer is that the set will pass two const reference to Person objects to your comparator, and you cannot call a non-const function on a const variable.

You might be surprised as there seems not to be any const in the declaration of the functor:

struct LessPerson
{
    template <typename Type>
    bool operator()(Type& t1, Type& t2)
    {
        return t1.ID() < t2.ID();
    }
};

But there is, it is just not explicit in the code. Inside the set implementation there are two const Person& references (call them r1, r2) and a LessPerson comparator (call it compare) and the code does something in the lines of if ( comparator(r1,r2) ). The compiler finds the templated operator() and tries to infer the types ending up with the type substitution: Type == const Person.

Why does the set use const references rather than plain modifiable references? Well, that is a different issue. The set is implemented as a sorted balanced tree, with each node containing the key. Now because a change in the key would break the order invariant, the keys are themselves const objects, ensuring that you cannot break the invariants.