Is this a valid less than operator for a map?

[dimstthomas]

I have a class that already has == and != operators that I want to use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?
bool MyClass::operator<(const MyClass &other) const
{
if (*this == other) return false;
return (this < &other);
}

I can declare and use a map variable using this operator

std::map<MyClass,std::string> m_MyClassCache;

I am worried that if the map is sorted and then something is added and
the map is reallocated by copying to a new array the previosly sorted
items may no longer be sorted. Is this likely to be a problem?

Thanks

[peter koch]

On 22 Aug., 12:51, "[e-mail]" <[e-mail]>
wrote:

I have a class that already has == and != operators that I want to use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?

bool MyClass::operator<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (this < &other);

}

No - it is not valid. Swapping the elements around will change the
predicate so that you for two elements could have a < b and b < a at
different times.

/Peter

[Ron AF Greve]

Hi,

Your key to the map sorts on the memory address i.e. pointer to it (usually
this is not what you want). Here is a key from a map i.e. the map[ Key ] =
Data; (The map only needs the < operator).
Example:

class MMyClass
{
private:
std::string Key1; // Part one of the key
std::string Key2; // Part two of the key
std::string Key3; // Part three of the key

public:
MMyClass( const std::string& Key1, const std::string& Key2, const
std::string& Key3):
Key1( Key1 ),
Key2( Key2 ),
Key3( Key3 )
{
}
bool operator<( const MMyClass& MyClass ) const
{
if( Key1 < MyClass.Key1 ) return true;
else if( Key1 == MyClass.Key1 )
{
if( Key2 < MyClass.Key2 ) return true;
else if( Key2 == MyClass.Key2 )
{
return Key3 < MyClass.Key3;
}
}

return false;
}
};


Regards, Ron AF Greve

http://www.InformationSuperHighway.eu

<di*********@yahoo.comwrote in message
news:eb**********************************@y21g2000 hsf.googlegroups.com...

>I have a class that already has == and != operators that I want to use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?
bool MyClass::operator<(const MyClass &other) const
{
if (*this == other) return false;
return (this < &other);
}

I can declare and use a map variable using this operator

std::map<MyClass,std::stringm_MyClassCache;

I am worried that if the map is sorted and then something is added and
the map is reallocated by copying to a new array the previosly sorted
items may no longer be sorted. Is this likely to be a problem?

Thanks

[dimstthomas]

On 22 Aug, 12:18, peter koch <[e-mail]:

On 22 Aug., 12:51, "[e-mail]" <[e-mail]>
wrote:

I have a class that already has == and != operators that I want to use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?

bool MyClass::operator<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (this < &other);

}

No - it is not valid. Swapping the elements around will change the
predicate so that you for two elements could have a < b and b < a at
different times.

I thought it was a bit dodgy. I have come up with a better solution
using an instance variable (which is not compared in the == operator):

class MyClass
{
...

private:
unsigned long m_instance;
static unsigned long m_instanceCount;
};

unsigned long MyClass::m_instanceCount = 0;

MyClass::MyClass() : m_instance(m_instanceCount++)
{
}

MyClass::MyClass(double x, double y) : m_instance(m_instanceCount++)
{
}

MyClass::MyClass(const MyClass& rhs) : m_instance(rhs.m_instance)
{
}

MyClass& MyClass::operator=(const MyClass& rhs)
{
if (this != &rhs)
{
...
m_instance = rhs.m_instance;
}
return *this;
}

bool MyClass::operator<(const MyClass &other) const
{
if (*this == other) return false;
return (m_instance < other.m_instance);
}

[dimstthomas]

On 22 Aug, 12:37, "Ron AF Greve" <ron@localhostwrote:

Hi,

Your key to the map sorts on the memory address i.e. pointer to it (usually
this is not what you want). Here is a key from a map i.e. the map[ Key ] =
Data; (The map only needs the < operator).
Example:

class MMyClass
{
* private:
* * std::string Key1; // Part one of the key
* * std::string Key2; // Part two of the key
* * std::string Key3; // Part three of the key

* public:
* * MMyClass( *const std::string& Key1, const std::string& Key2, const
std::string& Key3):
* * * Key1( Key1 ),
* * * Key2( Key2 ),
* * * Key3( Key3 )
* * {
* * }
* * bool operator<( const MMyClass& MyClass ) const
* * {
* * * if( Key1 < MyClass.Key1 ) return true;
* * * else if( Key1 == MyClass.Key1 )
* * * {
* * * * if( Key2 < MyClass.Key2 ) return true;
* * * * else if( Key2 == MyClass.Key2 )
* * * * {
* * * * * return Key3 < MyClass.Key3;
* * * * }
* * * }

* * * return false;
* * }

};

Regards, Ron AF Greve

Yes, but the problem is the class I am using has a lot of member data
and already has an == operator and I wanted to avoid having to write a
fully fledged < operator. See my other reply.

[dimstthomas]

On 22 Aug, 12:41, "[e-mail]" <[e-mail]>
wrote:

On 22 Aug, 12:18, peter koch <[e-mail]:

On 22 Aug., 12:51, "[e-mail]" <[e-mail]>
wrote:

I have a class that already has == and != operators that I wantto use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?

bool MyClass::operator<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (this < &other);

}

No - it is not valid. Swapping the elements around will change the
predicate so that you for two elements could have a < b and b < a at
different times.

I thought it was a bit dodgy. I have come up with a better solution
using an instance variable (which is not compared in the == operator):

class MyClass
{
...

private:
* * * * unsigned long m_instance;
* * * * static unsigned long m_instanceCount;

};

unsigned long MyClass::m_instanceCount = 0;

MyClass::MyClass() : m_instance(m_instanceCount++)
{

}

MyClass::MyClass(double x, double y) : m_instance(m_instanceCount++)
{

}

MyClass::MyClass(const MyClass& rhs) : m_instance(rhs.m_instance)
{

}

MyClass& MyClass::operator=(const MyClass& rhs)
{
* * * * if (this != &rhs)
* * * * {
* * * * * * * * ...
* * * * * * * * m_instance * *= rhs.m_instance;
* * * * }
* * * * return *this;

}

bool MyClass::operator<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (m_instance < other.m_instance);

}- Hide quoted text -

- Show quoted text -- Hide quoted text -

- Show quoted text -

This solution doesn't work either as the map doesn't compare every
item when inserting new items, I assume it does some kind of binary
search based on the sorted list (which is the whole point of a map!).
Looks like I will have to implement a proper less than operator.

[anon]

di*********@yahoo.com wrote:

On 22 Aug, 12:41, "[e-mail]" <[e-mail]>
wrote:

>On 22 Aug, 12:18, peter koch <[e-mail]:

>>On 22 Aug., 12:51, "[e-mail]" <[e-mail]>
wrote:
I have a class that already has == and != operators that I want to use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?
bool MyClass::operator<(const MyClass &other) const
{
if (*this == other) return false;
return (this < &other);
}
No - it is not valid. Swapping the elements around will change the
predicate so that you for two elements could have a < b and b < a at
different times.

I thought it was a bit dodgy. I have come up with a better solution
using an instance variable (which is not compared in the == operator):

class MyClass
{
...

private:
unsigned long m_instance;
static unsigned long m_instanceCount;

};

unsigned long MyClass::m_instanceCount = 0;

MyClass::MyClass() : m_instance(m_instanceCount++)
{

}

MyClass::MyClass(double x, double y) : m_instance(m_instanceCount++)
{

}

MyClass::MyClass(const MyClass& rhs) : m_instance(rhs.m_instance)
{

}

MyClass& MyClass::operator=(const MyClass& rhs)
{
if (this != &rhs)

Remove the above line with if

> {
...
m_instance = rhs.m_instance;
}
return *this;

}

bool MyClass::operator<(const MyClass &other) const
{
if (*this == other) return false;

Remove the above line with if

> return (m_instance < other.m_instance);

This solution doesn't work either as the map doesn't compare every
item when inserting new items, I assume it does some kind of binary
search based on the sorted list (which is the whole point of a map!).
Looks like I will have to implement a proper less than operator.

Why it doesn't work? It should work
Do you have a compilable example?

[Ron AF Greve]

Hi,

It is a lot of work :-(. Since I often access databases I actually got tired
of writing a key class everytime so I sort of created a simple javascript
that does some of the work. (It is just a quick script and not bugfree but
does the job for me, currently only supports strings though).

http://informationsuperhighway.eu/genkey.html
Regards, Ron AF Greve

http://www.InformationSuperHighway.eu

<di*********@yahoo.comwrote in message
news:de**********************************@a1g2000h sb.googlegroups.com...
On 22 Aug, 12:37, "Ron AF Greve" <ron@localhostwrote:

Hi,

Your key to the map sorts on the memory address i.e. pointer to it
(usually
this is not what you want). Here is a key from a map i.e. the map[ Key ] =
Data; (The map only needs the < operator).
Example:

class MMyClass
{
private:
std::string Key1; // Part one of the key
std::string Key2; // Part two of the key
std::string Key3; // Part three of the key

public:
MMyClass( const std::string& Key1, const std::string& Key2, const
std::string& Key3):
Key1( Key1 ),
Key2( Key2 ),
Key3( Key3 )
{
}
bool operator<( const MMyClass& MyClass ) const
{
if( Key1 < MyClass.Key1 ) return true;
else if( Key1 == MyClass.Key1 )
{
if( Key2 < MyClass.Key2 ) return true;
else if( Key2 == MyClass.Key2 )
{
return Key3 < MyClass.Key3;
}
}

return false;
}

};

Regards, Ron AF Greve

Yes, but the problem is the class I am using has a lot of member data
and already has an == operator and I wanted to avoid having to write a
fully fledged < operator. See my other reply.

[Greg Herlihy]

On Aug 22, 4:18*am, peter koch <[e-mail]:

On 22 Aug., 12:51, "[e-mail]" <[e-mail]>
wrote:

I have a class that already has == and != operators that I want to use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?

bool MyClass::operator<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (this < &other);

}

No - it is not valid. Swapping the elements around will change the
predicate so that you for two elements could have a < b and b < a at
different times.

I don't see why this operator<() would be invalid - that is, why it
would not produce a total ordering of MyClass elements. After all,
swapping the left and right elements would effectively also swap the
values of "other" and "this". And presumably whenever

this < &other

is true than

&other < this

will be false. Just as, whenever:

other == *this

is true, then

*this == other

is certain to be true as well.

Admittedly the operator<() here doesn't seem to have any practical
value. Nevertheless it does appear to me - to be valid.

Greg

[Pete Becker]

On 2008-08-22 08:13:31 -0400, "di*********@yahoo.com"
<di*********@yahoo.comsaid:

>
This solution doesn't work either as the map doesn't compare every
item when inserting new items, I assume it does some kind of binary
search based on the sorted list (which is the whole point of a map!).
Looks like I will have to implement a proper less than operator.

Good idea. If you have to fight with the design, chances are you're
doing something wrong.

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

[anon]

[huge snip]
This might help you solve the problem:
http://www.parashift.com/c++-faq-lit...t.html#faq-5.8

[peter koch]

On 22 Aug., 14:49, Greg Herlihy <[e-mail]:

On Aug 22, 4:18*am, peter koch <[e-mail]:

On 22 Aug., 12:51, "[e-mail]" <[e-mail]>
wrote:

I have a class that already has == and != operators that I wantto use
in a map that uses my class (not a pointer to the class) as the key.
To do this I need a < operator. Is this a valid less than operator to
use in this case?

bool MyClass::operator<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (this < &other);

}

No - it is not valid. Swapping the elements around will change the
predicate so that you for two elements could have a < b and b < a at
different times.

I don't see why this operator<() would be invalid - that is, why it
would not produce a total ordering of MyClass elements. After all,
swapping the left and right elements would effectively also swap the
values of "other" and "this". And presumably whenever

* * *this < &other

is true than

* * &other < this

will be false. Just as, whenever:

* * other == *this

is true, then

* * *this == other

is certain to be true as well.

Admittedly the operator<() here doesn't seem to have any practical
value. Nevertheless it does appear to me - to be valid.

Greg

I had the same initial thought as you: I do not remember this being
implicitly forbidden in the standard, but then I have not studied the
standard that much.
However, the problem is that the compares are not related to the
object but to some transient property of it.
When the object is to be inserted into the map, the address of the
object to be inserted will be used, but the moment the object is
inserted, the property changes.
The consequence is of course that this never is going to work: we will
get a map that is not sorted (or a crash), just as if we did apply a
comparison function that is not sanctioned by the standard.

/Peter

[terminator]

On Aug 22, 3:46 pm, "[e-mail]" <[e-mail]>
wrote:

On 22 Aug, 12:37, "Ron AF Greve" <ron@localhostwrote:

Hi,

Your key to the map sorts on the memory address i.e. pointer to it (usually
this is not what you want). Here is a key from a map i.e. the map[ Key ] =
Data; (The map only needs the < operator).
Example:

class MMyClass
{
private:
std::string Key1; // Part one of the key
std::string Key2; // Part two of the key
std::string Key3; // Part three of the key

public:
MMyClass( const std::string& Key1, const std::string& Key2, const
std::string& Key3):
Key1( Key1 ),
Key2( Key2 ),
Key3( Key3 )
{
}
bool operator<( const MMyClass& MyClass ) const
{
if( Key1 < MyClass.Key1 ) return true;
else if( Key1 == MyClass.Key1 )
{
if( Key2 < MyClass.Key2 ) return true;
else if( Key2 == MyClass.Key2 )
{
return Key3 < MyClass.Key3;
}
}

return false;
}

};

Regards, Ron AF Greve

Yes, but the problem is the class I am using has a lot of member data
and already has an == operator and I wanted to avoid having to write a
fully fledged < operator. See my other reply.

normally equality(==) operator is not intended to have the **ordering
property** and **you have to declare at least one ordering function in
case of need for sorting**.So do not be lazy to define at least one of
the operators < , =< , =,from each you can build the other three
and equality.
consider the complex numbers; mathematically you can test two complex
numbers against identity but there exists no formal ordering for
complex numbers exept personal interpretations.

regards,
FM.