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::operat or<(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<MyClas s,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, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
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::operat or<(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*********@ya hoo.comwrote in message
news:eb******** *************** ***********@y21 g2000hsf.google groups.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::operat or<(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<MyClas s,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 <peter.koch.lar [e-mail] ote:

On 22 Aug., 12:51, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
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::operat or<(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_inst anceCount = 0;

MyClass::MyClas s() : m_instance(m_in stanceCount++)
{
}

MyClass::MyClas s(double x, double y) : m_instance(m_in stanceCount++)
{
}

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

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

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

[dimstthomas]

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

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, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
wrote:

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

On 22 Aug., 12:51, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
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::operat or<(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_inst anceCount = 0;

MyClass::MyClas s() : m_instance(m_in stanceCount++)
{

}

MyClass::MyClas s(double x, double y) : m_instance(m_in stanceCount++)
{

}

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

}

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

}

bool MyClass::operat or<(const MyClass &other) const
{
* * * * if (*this == other) return false;
* * * * return (m_instance < other.m_instanc e);

}- 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*********@yah oo.com wrote:

On 22 Aug, 12:41, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
wrote:

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

>>On 22 Aug., 12:51, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
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::operat or<(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_inst anceCount = 0;

MyClass::MyCla ss() : m_instance(m_in stanceCount++)
{

}

MyClass::MyCla ss(double x, double y) : m_instance(m_in stanceCount++)
{

}

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

}

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

Remove the above line with if

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

}

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

Remove the above line with if

> return (m_instance < other.m_instanc e);

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*********@ya hoo.comwrote in message
news:de******** *************** ***********@a1g 2000hsb.googleg roups.com...
On 22 Aug, 12:37, "Ron AF Greve" <ron@localhostw rote:

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 <peter.koch.lar [e-mail] ote:

On 22 Aug., 12:51, "dimsttho...@ya hoo.com" <dimsttho...@ya hoo.com>
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::operat or<(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*********@ya hoo.com"
<di*********@ya hoo.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)