Re: Is a std::map<> ordered?

[Juha Nieminen]

joseph cook wrote:

A map is always sorted using std::less

Not always. By default, yes, but you can specify other comparators, eg:

std::map<int, int, std::greaterreversedMap;

[acehreli]

On Nov 20, 7:48*am, Juha Nieminen <[e-mail]:

joseph cook wrote:

A map is always sorted using std::less

* Not always. By default, yes, but you can specify other comparators, eg:

std::map<int, int, std::greaterreversedMap;

Or at runtime:

std::map<int, intmyMap(myPredicate);

Ali

[Pete Becker]

On 2008-11-20 14:40:19 -0500, ac******@gmail.com said:

On Nov 20, 7:48Â*am, Juha Nieminen <[e-mail]:

>joseph cook wrote:

>>A map is always sorted using std::less

Â* Not always. By default, yes, but you can specify other comparators, e

g:

>>
std::map<int, int, std::greaterreversedMap;

Or at runtime:

std::map<int, intmyMap(myPredicate);

Not really. There's a third type argument to std::map which specifies
the map's predicate type, with a default of std::less<T>. This
constructor takes an argument with the same type as the template's
predicate argument, so you can't pass arbitrary predicate objects. This
constructor is only useful with a user-defined predicate type that can
be initialized with something other than its default constructor.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Rolf Magnus]

Pete Becker wrote:

On 2008-11-20 14:40:19 -0500, ac******@gmail.com said:

>On Nov 20, 7:48 am, Juha Nieminen <[e-mail]:

>>joseph cook wrote:
A map is always sorted using std::less

Not always. By default, yes, but you can specify other comparators, e

g:

>>>
std::map<int, int, std::greaterreversedMap;

Or at runtime:

std::map<int, intmyMap(myPredicate);

Not really. There's a third type argument to std::map which specifies
the map's predicate type, with a default of std::less<T>. This
constructor takes an argument with the same type as the template's
predicate argument, so you can't pass arbitrary predicate objects. This
constructor is only useful with a user-defined predicate type that can
be initialized with something other than its default constructor.

Well, basically that just does mean that it depends on a runtime value.
Otherwise, you wouldn't need those constructor arguments in the first place.

[Juha Nieminen]

ac******@gmail.com wrote:

std::map<int, intmyMap(myPredicate);

I don't think you can do that because the comparator template
parameter is set by default to std::less, and unless myPredicate casts
implicitly to type std::less, that won't work. You have to do it like:

std::map<int, int, MyPredicateTypemyMap(myPredicate);

If 'myPredicate' is a function, the syntax becomes awkward:

std::map<int, int, bool(*)(int, int)myMap(myPredicate);

This becomes even more awkward if the key and data types of the map
are something more complicated than int.

The next standard will offer a tool to alleviate the problem:

std::map<int, int, decltype(myPredicate)myMap(myPredicate);

[Pete Becker]

On 2008-11-21 06:34:27 -0500, Rolf Magnus <ra******@t-online.desaid:

Pete Becker wrote:

>On 2008-11-20 14:40:19 -0500, ac******@gmail.com said:

>>On Nov 20, 7:48 am, Juha Nieminen <[e-mail]:
joseph cook wrote:
A map is always sorted using std::less

Not always. By default, yes, but you can specify other comparators, e
g:

std::map<int, int, std::greaterreversedMap;

Or at runtime:

std::map<int, intmyMap(myPredicate);

Not really. There's a third type argument to std::map which specifies
the map's predicate type, with a default of std::less<T>. This
constructor takes an argument with the same type as the template's
predicate argument, so you can't pass arbitrary predicate objects. This
constructor is only useful with a user-defined predicate type that can
be initialized with something other than its default constructor.

Well, basically that just does mean that it depends on a runtime value.
Otherwise, you wouldn't need those constructor arguments in the first place.

It means that std::map<int, intmyMap(myPredicate) is an error unless
the type of myPredicate is std::less<int>, in which cast it's
irrelevant. In particular, it is not a runtime replacement for
std::map<int, int, std::greater<int>>.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Pete Becker]

On 2008-11-21 08:46:16 -0500, Juha Nieminen <no****@thanks.invalidsaid:

ac******@gmail.com wrote:

>std::map<int, intmyMap(myPredicate);

I don't think you can do that because the comparator template
parameter is set by default to std::less, and unless myPredicate casts
implicitly to type std::less, that won't work. You have to do it like:

std::map<int, int, MyPredicateTypemyMap(myPredicate);

If 'myPredicate' is a function, the syntax becomes awkward:

std::map<int, int, bool(*)(int, int)myMap(myPredicate);

Well, yes, and as we've seen in many Ginsu knife commercials, a normal
knife can't slice a tomato. The way to write this code is, of course,
with appropriate typedefs:

typedef bool (*pred)(int,int);
std::map<int, int, predmyMap(myPredicate);

>
This becomes even more awkward if the key and data types of the map
are something more complicated than int.

Not at all. Again, typedefs.

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)