重载模板类比较运算符

Question

I am having a ton of trouble with overloading comparison operators in C++. I don't think I am doing it correctly, any help is appreciated. I have provided a snippet of my class below.

template <typename T>
class A
{
public:
    template <typename T>
    bool operator<  (const A<T>& rhs) const {
        return (value < rhs);
    }
private:
    T value;
};

Answer 1

If you want both A objects to be parameterized with the same type T , remove the inner template <typename T> on the operator.

Otherwise, if you want the operator to take an A with a different type parameter than T , change the inner template <typename T> to template <typename U> , and change rhs to const A<U>& rhs .

Answer 2

You can't define nested templates with the same parameter names.

If your operator< accepts an A object whose template parameter is a different type then the A object being compared to, you have to use different template parameter names:

template <typename T>
class A
{
public:
    template <typename Other>
    bool operator< (const A<Other>& rhs) const {
        return (value < rhs.value);
    }
private:
    T value;
};

This will work as long as T and Other are types that are comparable with < .

However, if you are comparing two A objects that have the same template type, there is no need for operator< to have its own template at all:

template <typename T>
class A
{
public:
    bool operator< (const A<T>& rhs) const {
        return (value < rhs.value);
    }
private:
    T value;
};

Answer 3

If you want to support simple use cases, such as:

A<int> a = { some_value };
A<int> b = { some_other_value } ;

if ( a < b ) { ... }

there is no need for the operator< function to be member function template. You can simplify your code to:

template <typename T>
class A
{
  public:
    bool operator<(const A& rhs) const {
        return (value < rhs.value);
    }
  private:
    T value;
};

If you want to be able to use:

A<int> a = { some_value };
A<float> b = { some_other_value } ;

if ( a < b ) { ... }

then the operator< function needs to be a member function template. However, make sure that the two template parameter names are different. You can use:

template <typename T>
class A
{
  public:
    template <typename T1>
    bool operator<(const A<T1>& rhs) const {
        return (value < rhs.value);
    }  
  private:
    T value;
};

That will work as long as T and T1 support such an operation.

Answer 4

I am not sure if you want two different template parameters, or one. This is the solution with only one typename (I also added getter for value, just because I prefer to). You don't need inside definition of template and you need to compare the values of the instances, not just value and instance A.

template <typename T>
class A {
public:
    bool operator < (const A<T> & rhs) const {
        return (value < rhs.getValue());
    }

   const T & getValue() const{
        return this -> value;
    }
private:
    T value;
};

If you want two template arguments there, that is more complicated. Unless you have just few classes that need to work like this, you can do < operator for each. Otherwise it could get messy and I am sure there would be nicer solution for what you want to do.