C ++ STL集的比较函数：比较函数可以是类的成员函数吗？

Question

I have to use STL set and I want to define my own comparison function. But as per my requirement this comparison function shouldn't be a global, rather should be a public member of a class.

//CLASS DEFINITION
class IDENTIFERS
{
public:
         IDENTIFIERS();
         ~IDENTIFIERS();
bool     compare_identifier(int Identifier, int Identifier);

public:
std::set <Identifier, bool(*)(Identifier, Identifier)>      set_instance;

};

//CLASS Constructor
IDENTIFIERS::IDENTIFIERS()
{
std::set <Identifier, bool(*)(Identifier, Identifier)>   set_instance(compare_identifier);
}

If I write a piece a code as mentioned above. It doesn't compile as comparison function's prototype doesn't match with compare_identifier() function.

Is there a way to do it?

Answer 1

A non-static member function takes an implicit first parameter for this , so your compare_identifier actually has three parameters. If you need it to be a non-static member function, you need to bind the member function's implicit first parameter to an instance of IDENTIFIERS , for example,

#include <set>
#include <functional>

struct Identifier { int id; };

class IDENTIFERS
{
public:
  IDENTIFERS() : set_instance(std::bind(&IDENTIFERS::compare_identifier,
                                        this,                                               
                                        std::placeholders::_1,
                                        std::placeholders::_2))
  {}
  bool  compare_identifier(const Identifier& lhs, const Identifier& rhs)
  {
    return lhs.id < rhs.id;
  }

public:
  std::set <Identifier, std::function<bool(const Identifier&, const Identifier&)>> set_instance;

};

Answer 2

Making compare_identifier() static is the easiest way to solve this. Here is how you can fix your code so that it compiles, assuming Identifier is defined elsewhere:

// Watch for the typo (missing 'I') in your code above
class IDENTIFIERS // Note, all-uppercase names are usually reserved for macros
{
public:
    IDENTIFIERS();

    // N.B: This function needs to take two `Identifier`s as its arguments
    // (not two `int`s)    
    static bool compare_identifier(Identifier const &l, Identifier const& r)
    {
       return l.custom_less_than(r);
    }

    // typedefs can make your code more readable, especially with function pointers.
    typedef bool (*identifier_comparator)(Identifier const &l, Identifier const& r);
    typedef std::set<Identifier, identifier_comparator> identifier_set;
    identifier_set set_instance;
};

IDENTIFIERS::IDENTIFIERS()
    :set_instance(compare_identifier) // Initialise here
{
    // Don't shadow `set_instance` in the body of the constructor!
} 

Following comment

Making compare_identifier() static (in IDENTIFIERS ) will not affect the accessibility of members of the Identifier class . The logic to compare two Identifier objects should reside either within Identifier , like this:

class Identifier
{
public:
    // If you define this, then you won't need to specify a custom comparator
    bool operator <(Identifier const& r) const
    {
        // return true if `*this` is logically less-than `r`; false otherwise.
    }

    bool custom_less_than(Identifier const& r) const
    {
        // Some other way of comparing objects. Perhaps reverse-alphabetically
        // or similar.
        // return true if `*this` is logically less-than `r`; false otherwise.
    } 
};

...or within free functions but these won't have access to the private members.

Answer 3

There are a number of errors in your sample code.

The zero-th error is somewhat style-related: classes should be named all-lowercase-with-underscores or CamelCase.

The first error:

bool compare_identifier(int Identifier, int Identifier);

you can't have the same identifier for both function parameters (also, style-related, function parameters should be all-lowercase or camelCased), like

bool compare_identifier(int id1, int id2);

The second error is that this:

std::set <Identifier, bool(*)(Identifier, Identifier)> set_instance;

assumes that you have a class Identifier somewhere. Which something tells me you don't, since your class is called IDENTIFIERS . If you do have an Identifier class, I should assume that your compare_identifier function is like:

bool compare_identifier(const Identifier& id1, const Identifier& id2);

and that your set_instance declaration is like:

std::set<Identifier, bool(*)(const Identifier&, const Identifier&)> set_instance;

The third error is that your constructor does not do what you are assuming it does (constructing the set_instance member), but it would be (if syntatically valid) constructing a local variable called set_instance . So, your constructor should go something like:

IdentifierBucket::IdentifierBucket() :
  set_instance(std::bind(compare_identifier, this, _1, _2)) {
}

But all this is moot... because the comparator for set also does not do what you think it does (see if two items are equal or not) but it gives them order (the default comparator is std::less ...

What you really want is something like:

#include <set>
#include <functional>

struct Identifier {};

struct IdentifierComparator {
  IdentifierComparator() {};
  bool operator()(Identifier id1, Identifier id2); // WRITE THIS
};

class IdentifierBucket {
public:
  IdentifierBucket() {};
  ~IdentifierBucket() {};

private:
  std::set <Identifier, IdentifierComparator> set_instance;
};