cannot overload allocator because cannot define "less"

[icegood]

Have next piece of code:

typedef struct _TMovedMols
  {
  private:
    union
    {
      uint32_t dummy;
      struct
      {
        unsigned int UniqueMolID:31;
        unsigned int Direction:1;
      };
    };
  public:
    _TMovedMols(int AUniqueMolID=0, int ADirection=0)
    {
      UniqueMolID=AUniqueMolID;
      Direction=ADirection;
    }
    
    _TMovedMols(const _TMovedMols &other)
    {
      dummy=other.dummy;
    }
    
    inline _TMovedMols & operator = (const _TMovedMols &other)
    {
      dummy=other.dummy;
      return *this;
    }
    
    inline bool operator < (const _TMovedMols &other) const
    {
      return UniqueMolID < other.UniqueMolID;
    }
  } TMovedMols;

class TLocalSetAllocator ...;

typedef std::set<TMovedMols, less <TMovedMols>, TLocalSetAllocator<TMovedMols> > my_set_t;

Obtained

test_set.cpp:146:3: error: ‘less’ was not declared in this scope
test_set.cpp:146:3: note: suggested alternative:

It's very first error form compiler, so no history. Does "less" supposed to be synonim to "<"?

[Cubbi]

It's std::less, and it is defined in the include file <functional>

(incidentally, why define your struct as both _TMovedMols and TMovedMols? One name is enough)

To quote clang++,

test.cc:42:30: error: no template named 'less'; did you mean 'std::less'?
typedef std::set<TMovedMols, less <TMovedMols>,...
                             ^~~~
                             std::less

also, regarding your struct inside a union inside TMovedMols,

test.cc:10:13: error: anonymous structs are a GNU extension
      [-Werror,-pedantic,-Wgnu]
            struct
            ^

[MikeyBoy]

You haven't namespace-qualified "less". It should be std::less.

According to the documentation on this very site:

http://www.cplusplus.com/reference/functional/less/

less is a template for a function object - that is, an object whose () operator has been overridden to return a value. The less template overrides the () operator to return the results of a < comparison between its two arguments.

In other words, if you create an object:

std::less<MyType> lessObj;

and:

MyType a;
MyType b;

/* Set the values of a and b */

then

lessObj(a, b)

gives the same result as:

a < b