find() of std::set

[Christian Meier]

Hello Newsgroup

I have a question about the find function of std::set.
When I have a "std::set<int*>", why can't I call the find() function with an
"const int*"? I know that my key type is different from the type of the
parameter I give to the find function but can't the find() function be
written in a way where this would work? Normally, "int*" can be compared
with "const int*" without problems...
And as a follow-up question: What would you do in a function like this:

void MyClass::myFunc(const LargeObject* input)
{
// ...
// m_LargeObjectSet is a member variable of the class MyClass and has
the type "std::set<LargeObject*>". How would you write the following line?
const_const? Copy the large object?
// m_LargeObjectSet.find(input);
// ...
}

The function already exists and I would have to rewrite quite a lot of code
when I would remove the "const" of the parameter type.
Do you have any suggestions?
Thanks & greetings
Chris

[Rolf Magnus]

Christian Meier wrote:

Hello Newsgroup

I have a question about the find function of std::set.
When I have a "std::set<int*>", why can't I call the find() function with
an "const int*"? I know that

Because:

my key type is different from the type of the parameter I give to the find
function but can't the find() function be written in a way where
this would work?

I guess it could in theory. But it would mean that the class std::set would
have to be specialized just for this specific case.

Normally, "int*" can be compared with "const int*" without problems...
And as a follow-up question: What would you do in a function like this:

void MyClass::myFunc(const LargeObject* input)
{
// ...
// m_LargeObjectSet is a member variable of the class MyClass and has
the type "std::set<LargeObject*>". How would you write the following line?
const_const? Copy the large object?
// m_LargeObjectSet.find(input);

m_LargeObjectSet.find(const_cast<LargeObject*>(inp ut));

// ...
}

[Joe Smith]

Rolf Magnus wrote:

Christian Meier wrote:

>Hello Newsgroup

I have a question about the find function of std::set.
When I have a "std::set<int*>", why can't I call the find() function with
an "const int*"? I know that

Because:

>my key type is different from the type of the parameter I give to the
find
function but can't the find() function be written in a way where
this would work?

I guess it could in theory. But it would mean that the class std::set
would
have to be specialized just for this specific case.

I think in general, a "const T*" can be compaired with a "T*", no?

Unfortuneately, the way the language works "const T&" with T=int* is not the
same
as const int*&.

What is the reasoning behind that?

[Bo Persson]

Joe Smith wrote:

Rolf Magnus wrote:

>Christian Meier wrote:

>>Hello Newsgroup

I have a question about the find function of std::set.
When I have a "std::set<int*>", why can't I call the find()
function with an "const int*"? I know that

Because:

>>my key type is different from the type of the parameter I give to
the find
function but can't the find() function be written in a way where
this would work?

I guess it could in theory. But it would mean that the class
std::set would
have to be specialized just for this specific case.

I think in general, a "const T*" can be compaired with a "T*", no?

Unfortuneately, the way the language works "const T&" with T=int*
is not the same
as const int*&.

What is the reasoning behind that?

The reason is that "const T" should mean the same as "T const". So you
get "int* const&".

The type system works differently than #define macros - it is not a
straight text substitution.
Bo Persson

[Joe Smith]

"Bo Persson" <bo*@gmb.dkwrote in message
news:6n***********@mid.individual.net...

Joe Smith wrote:

>Rolf Magnus wrote:

>>Christian Meier wrote:

Hello Newsgroup

I have a question about the find function of std::set.
When I have a "std::set<int*>", why can't I call the find()
function with an "const int*"? I know that

Because:

my key type is different from the type of the parameter I give to
the find
function but can't the find() function be written in a way where
this would work?

I guess it could in theory. But it would mean that the class
std::set would
have to be specialized just for this specific case.

I think in general, a "const T*" can be compaired with a "T*", no?

Unfortuneately, the way the language works "const T&" with T=int*
is not the same
as const int*&.

What is the reasoning behind that?

The reason is that "const T" should mean the same as "T const". So you get
"int* const&".

Right. Doh!

Obviously a "reference to a constant pointer to an integer" (quite the mouth
full) is the right way for the compiler to interpret that.

[James Kanze]

On Nov 10, 3:26*pm, "Christian Meier" <chris@no_spam.comwrote:

I have a question about the find function of std::set.
When I have a "std::set<int*>", why can't I call the find()
function with an "const int*"? I know that my key type is
different from the type of the parameter I give to the find
function but can't the find() function be written in a way
where this would work? Normally, "int*" can be compared with
"const int*" without problems...

The problem is that std::set<>::find() takes the key by
reference, and a reference to an int* cannot be initialized with
an int const*&. (If you could, then you could modify a const
object without a const cast.)

And as a follow-up question: What would you do in a function
like this:

void MyClass::myFunc(const LargeObject* input)
{
* * // ...
* * // m_LargeObjectSet is a member variable of the class MyClass andhas
the type "std::set<LargeObject*>". How would you write the following line?
const_const? Copy the large object?
* * // m_LargeObjectSet.find(input);
* * // ...
}

The function already exists and I would have to rewrite quite
a lot of code when I would remove the "const" of the parameter
type. Do you have any suggestions?

The real question is what your std::set should really contain.
Perhaps it would be more appropriate for it to contain MyType
const*, rather than just MyType*. Not knowing what the role of
the set is, I can't say. Most of the time, if the set contains
pointers, you want to specialize the comparison to be based on
the pointed to object. In which case, the pointer had better be
to const.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Nov 10, 4:08*pm, Rolf Magnus <[e-mail]:

Christian Meier wrote:

I have a question about the find function of std::set. When
I have a "std::set<int*>", why can't I call the find()
function with an "const int*"? I know that *

Because:

my key type is different from the type of the parameter I
give to the find function but can't the find() function be
written in a way where this would work?

I guess it could in theory. But it would mean that the class
std::set would have to be specialized just for this specific
case.

Not at all. All it would require is that set<>::find() take
its argument by value, and not by reference. Which would have
been the better design to begin with.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Nov 10, 7:48*pm, "Joe Smith" <[e-mail]:

Rolf Magnus wrote:

Christian Meier wrote:

Unfortuneately, the way the language works "const T&" with
T=int* is not the same as const int*&.

What is the reasoning behind that?

Because it would break const:

void
f( int const* p )
{
int*& r = p ;
*r = 42 ;
}

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]