Sorting a map<T*>

[barcaroller]

I have a map<T*that stores pointers to objects. How can I tell map<T*to
use the objects' operator<() and not the value of the pointers for sorting?

If that's not feasible, what alternatives do I have to sort a set of objects
that cannot and should not be copied (i.e. I can use only pointers to these
objects)?

Note: I am aware of the method of creating a new class that wraps the
pointers of the objects and then provides its own operator<(). However, I
am trying to avoid creating new classes.

[red floyd]

barcaroller wrote:

I have a map<T*that stores pointers to objects. How can I tell map<T*to
use the objects' operator<() and not the value of the pointers for sorting?

There is no map<T*>. map takes (at least) two template parameters --
the key and the value.

If that's not feasible, what alternatives do I have to sort a set of objects
that cannot and should not be copied (i.e. I can use only pointers to these
objects)?

Note: I am aware of the method of creating a new class that wraps the
pointers of the objects and then provides its own operator<(). However, I
am trying to avoid creating new classes.

Why? If it does the job?

[barcaroller]

"red floyd" <no*****@here.d udewrote in message
news:EB******** *********@newss vr23.news.prodi gy.net...

There is no map<T*>. map takes (at least) two template parameters --
the key and the value.

I'm sorry; my mistake. I meant set<T*>.

[Michael]

On May 7, 3:01 pm, "barcarolle r" <barcarol...@mu sic.netwrote:

I have a set<T*that stores pointers to objects. How can I tell set<T*to
use the objects' operator<() and not the value of the pointers for sorting?

There's a way to create a set with two parameters: set<MyType,
key_comp>, where
key_comp is a key comparison function you define. For example,
set<int, less<int.

So then you'd just need to provide the appropriate comparison function
that uses
the objects' operator<(), suitably wrapped.

Michael

[Markus Schoder]

On Mon, 07 May 2007 16:11:52 -0700, Michael wrote:

On May 7, 3:01 pm, "barcarolle r" <barcarol...@mu sic.netwrote:

>I have a set<T*that stores pointers to objects. How can I tell
set<T*to use the objects' operator<() and not the value of the
pointers for sorting?

There's a way to create a set with two parameters: set<MyType,
key_comp>, where
key_comp is a key comparison function you define. For example, set<int,
less<int.

So then you'd just need to provide the appropriate comparison function
that uses
the objects' operator<(), suitably wrapped.

Actually you need a class with an appropriate operator(). A plain
function won't do here since you cannot pass it as a template parameter.

--
Markus

[Pete Becker]

Markus Schoder wrote:

On Mon, 07 May 2007 16:11:52 -0700, Michael wrote:

>On May 7, 3:01 pm, "barcarolle r" <barcarol...@mu sic.netwrote:

>>I have a set<T*that stores pointers to objects. How can I tell
set<T*to use the objects' operator<() and not the value of the
pointers for sorting?

There's a way to create a set with two parameters: set<MyType,
key_comp>, where
key_comp is a key comparison function you define. For example, set<int,
less<int.

So then you'd just need to provide the appropriate comparison function
that uses
the objects' operator<(), suitably wrapped.

Actually you need a class with an appropriate operator(). A plain
function won't do here since you cannot pass it as a template parameter.

Sure you can. Try it.

--

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

[Markus Schoder]

On Mon, 07 May 2007 19:45:00 -0400, Pete Becker wrote:

Markus Schoder wrote:

>On Mon, 07 May 2007 16:11:52 -0700, Michael wrote:

>>On May 7, 3:01 pm, "barcarolle r" <barcarol...@mu sic.netwrote:
I have a set<T*that stores pointers to objects. How can I tell
set<T*to use the objects' operator<() and not the value of the
pointers for sorting?
There's a way to create a set with two parameters: set<MyType,
key_comp>, where
key_comp is a key comparison function you define. For example,
set<int, less<int.

So then you'd just need to provide the appropriate comparison function
that uses
the objects' operator<(), suitably wrapped.

Actually you need a class with an appropriate operator(). A plain
function won't do here since you cannot pass it as a template
parameter.

Sure you can. Try it.

No you cannot. I guess you are confusing this with algorithms like
std::lower_boun d where you can specify a predicate as a _function_
parameter. As a template parameter for std::set or std::map this does not
work. Think about it -- it needs to be a type.

--
Markus

[Greg Herlihy]

On 5/7/07 5:01 PM, in article pa************* ********@yahoo. de, "Markus
Schoder" <a3************ *@yahoo.dewrote :

On Mon, 07 May 2007 19:45:00 -0400, Pete Becker wrote:

>Markus Schoder wrote:

>>On Mon, 07 May 2007 16:11:52 -0700, Michael wrote:
On May 7, 3:01 pm, "barcarolle r" <barcarol...@mu sic.netwrote:
I have a set<T*that stores pointers to objects. How can I tell
set<T*to use the objects' operator<() and not the value of the
pointers for sorting?
There's a way to create a set with two parameters: set<MyType,
key_comp>, where
key_comp is a key comparison function you define. For example,
set<int, less<int.

So then you'd just need to provide the appropriate comparison function
that uses
the objects' operator<(), suitably wrapped.

Actually you need a class with an appropriate operator(). A plain
function won't do here since you cannot pass it as a template
parameter.

Sure you can. Try it.

No you cannot. I guess you are confusing this with algorithms like
std::lower_boun d where you can specify a predicate as a _function_
parameter. As a template parameter for std::set or std::map this does not
work. Think about it -- it needs to be a type.

But std::set's Compare type may be a function type - it does not need to be
a class type that has an overloaded operator() defined. So Pete's objection
is correct - and here is some code to demonstrate:

#include <set>

bool MyComp(int *a, int *b)
{
return *a < *b;
}

int main()
{
std::set<int*, bool (*)(int*, int*)s(MyComp);

s.insert( new int(1) );
s.insert( new int(2) );
...
}

Greg

[Sylvester Hesp]

"Markus Schoder" <a3************ *@yahoo.dewrote in message
news:pa******** *************@y ahoo.de...

On Mon, 07 May 2007 19:45:00 -0400, Pete Becker wrote:

>Markus Schoder wrote:

>>Actually you need a class with an appropriate operator(). A plain
function won't do here since you cannot pass it as a template
parameter.

Sure you can. Try it.

No you cannot. I guess you are confusing this with algorithms like
std::lower_boun d where you can specify a predicate as a _function_
parameter. As a template parameter for std::set or std::map this does not
work. Think about it -- it needs to be a type.

And at what point in time did functions stop having types? :)

bool mycompfunc(int, int);
std::set<int, bool(*)(int, int)myset(mycom pfunc);

- Sylvester Hesp

[Thomas J. Gritzan]

barcaroller schrieb:

I have a map<T*that stores pointers to objects. How can I tell map<T*to
use the objects' operator<() and not the value of the pointers for sorting?

std::map has 4 template parameters. The 3rd is a compare functor. Write a
functor that simply maps to the objects operator<().

In std::set, it's the second template parameter.

--
Thomas
http://www.netmeister.org/news/learn2quote.html