discards qualifiers

[John]

Hello!

When I compile the following code, I get this error message "error:
passing ... discards qualifiers" and I don't understand why.

Could anybody help me?

Thank you!

John
-----main.cpp------
....
map<Pair<string , string>, int> myMap;
myMap(Pair<stri ng, string>("bla", "blablabla" )) = 2;
....

-----Pair.h-------
template <class T1, class T2>
class Pair
{
public:
T1 first;
T2 second;
Pair();
Pair(T1 first, T2 second);
virtual ~Pair();
bool operator == (Pair<T1, T2> p);
bool operator < (Pair<T1, T2> p);
};

-----Pair.cpp-------
#include "Pair.h"

template <class T1, class T2>
Pair<T1, T2>::Pair()
{
}

template <class T1, class T2>
Pair<T1, T2>::Pair(T1 first, T2 second)
{
this->first = first;
this->second = second;
}

template <class T1, class T2>
Pair<T1, T2>::~Pair()
{
}

template <class T1, class T2>
bool Pair<T1, T2>::operator == (Pair<T1, T2> p)
{
return (first == p.first && second == p.second) || (first == p.second
&& second == p.first);
}

template <class T1, class T2>
bool Pair<T1, T2>::operator < (Pair<T1, T2> p)
{
return first < p.first || (!(p.first < first) && second < p.second);
}

[Ian Collins]

John wrote:

Hello!

When I compile the following code, I get this error message "error:
passing ... discards qualifiers" and I don't understand why.

Could anybody help me?
See comments inline.
Thank you!

John
-----main.cpp------
...
map<Pair<string , string>, int> myMap;
myMap(Pair<stri ng, string>("bla", "blablabla" )) = 2;
use qualified names, std::map, std::string. ...

-----Pair.h-------
template <class T1, class T2>
class Pair
{
public:
T1 first;
T2 second;
Pair();
Pair(T1 first, T2 second);
virtual ~Pair();
bool operator == (Pair<T1, T2> p);
bool operator < (Pair<T1, T2> p);
These should both be (const Pair& p) const.
};

-----Pair.cpp-------
#include "Pair.h"

template <class T1, class T2>
Pair<T1, T2>::Pair()
{
}

template <class T1, class T2>
Pair<T1, T2>::Pair(T1 first, T2 second)
{
this->first = first;
this->second = second;
Prefer initialiser lists.
}

template <class T1, class T2>
Pair<T1, T2>::~Pair()
{
}

template <class T1, class T2>
bool Pair<T1, T2>::operator == (Pair<T1, T2> p)
{
return (first == p.first && second == p.second) || (first == p.second
&& second == p.first);
}

template <class T1, class T2>
bool Pair<T1, T2>::operator < (Pair<T1, T2> p)
{
return first < p.first || (!(p.first < first) && second < p.second);
}

--
Ian Collins.

[John Carson]

"John" <cy***@purecode .ch> wrote in message
news:11******** ****@sicinfo3.e pfl.ch

Hello!

When I compile the following code, I get this error message "error:
passing ... discards qualifiers" and I don't understand why.

Could anybody help me?

Thank you!

John
-----main.cpp------
...
map<Pair<string , string>, int> myMap;
myMap(Pair<stri ng, string>("bla", "blablabla" )) = 2;
The standard library includes a templated functional called less. less is a
struct that has an operator() that takes two arguments and applies < to
them. The two arguments are declared as const, which means that it is not
permissible to call any operator on them which is not likewise const.
Calling a non-const operator "discards qualifiers", i.e., discards const.

By default, map uses less to compare keys. less is calling your operator<.
Since your operator< is non-const, you are getting the error message.

-----Pair.h-------
template <class T1, class T2>
class Pair
{
public:
T1 first;
T2 second;
Pair();
Pair(T1 first, T2 second);
virtual ~Pair();
bool operator == (Pair<T1, T2> p);
bool operator == (const Pair<T1, T2> p) const;

(the first const says you aren't going to modify the "other" Pair; the
second const says the Pair isn't going to modify itself.) You need to make
the same changes to the implementation --- see below
bool operator < (Pair<T1, T2> p);
bool operator < (const Pair<T1, T2> p) const;
};
Unless your compiler supports export, this separation into .h and .cpp files
won't work. You need to put the implementation into the .h file when using
templates (more precisely, the implementation needs to be visible in the
translation unit that is using it --- the compiler has to be able to see it;
you can't rely on the linker).
-----Pair.cpp-------
#include "Pair.h"

template <class T1, class T2>
Pair<T1, T2>::Pair()
{
}

template <class T1, class T2>
Pair<T1, T2>::Pair(T1 first, T2 second)
{
this->first = first;
this->second = second;
}

template <class T1, class T2>
Pair<T1, T2>::~Pair()
{
}

template <class T1, class T2>
bool Pair<T1, T2>::operator == (Pair<T1, T2> p)
bool Pair<T1, T2>::operator == (const Pair<T1, T2> p) const
{
return (first == p.first && second == p.second) || (first == p.second
&& second == p.first);
}

template <class T1, class T2>
bool Pair<T1, T2>::operator < (Pair<T1, T2> p)
bool Pair<T1, T2>::operator < (const Pair<T1, T2> p) const
{
return first < p.first || (!(p.first < first) && second < p.second);
}

--
John Carson