boost::lambda in std::map

[porp...@gmail.com]

Hi

I would like to implement my own comparator for std::map using boost::lambda (no C++11 capable compiler).
I wrote my very first version of such comparator.
Unfortunately I cannot compile it. I get the following compilation error:

'boost::lambda::{anonymous}::_1' cannot appear in a constant-expression
'boost::lambda::{anonymous}::_2' cannot appear in a constant-expression

Please help me to overcome this error.

thanks in advance

#include <map>
#include <string>
#include <boost/lambda/lambda.hpp>

using namespace std;
using namespace boost::lambda;

int main(void)
{
map<string, string, (_1 < _2)> myMap;
return 0;
}

[Öö Tiib]

That is because you are mixing the values and the types of the
values up. As result the compiler does not understand what you
want to do. Perhaps you should try it step-by-step?
DISCLAIMER: I have no compiler nearby so I can't guarantee it does
not have typos or something but it must illustrate the idea:

// 1) Should such code work?:
typedef boost::function<bool(std::string const&, std::string const&)> Comparator;
// what happened on above line?

// 2) After it should that work?:
Comparator c = _1 < _2;
// what happened on above line?

// 3) Now ... does that work?:
typedef std::map<std::string, std::string, Comparator> StrToStr;
// what happened on above line?

// 4) So ... does that work?:
StrToStr myMap(c);
// what happened on above line?

When you understand these elementary steps then you can perhaps start
to write more complex lines of C++:

int main()
{
map<string, string, function<bool (string const&, string const&)> > myMap(_1 < _2);
return 0;
}

I myself avoid writing such complex lines. It looks too lot like
cryptic garbage.

[porp...@gmail.com]

Thanks for reply.
I thought that lambda expression like (_1<_2) generates functor. It looks like it rather generates an object of a functor, right ? This is the source of my confusion.
I also wonder why the following does not compile
map<string, string> myMap(_1<_2)

I suspect that most probably the 3-rd template parameter is difficult to deduce and a compiler just gives up. Am I right ?

[Öö Tiib]

Yes, make clear difference in your mind about what is type what is
variable what is function and what is function call.

> I also wonder why the following does not compile
> map<string, string> myMap(_1<_2)

Where it is written that you can define such variable?:

std::less<std::string> c = _1 < _2;

You can't. C++ is not voo-doo shamanism of dark wizards. It is clear,
strongly-typed programming language.

> I suspect that most probably the 3-rd template parameter is difficult to
> deduce and a compiler just gives up. Am I right ?

How? Now you mix up function templates and class templates. C++ does not
deduce type of class by constructor arguments. You will be wrong for
several years to come if you try to deduce what a line of code does by
looking at it and philosophizing what it "most probably" does.

Instead look into specification of 'std::map':

template < class Key, // map::key_type
class T, // map::mapped_type
class Compare = less<Key>, // map::key_compare
class Alloc // map::allocator_type
= allocator<pair<const Key,T> >
> class map;

What is the trick that it allows you to declare?:

map<string, string> x;

What is fully written out type of 'x' on above line?