operator == overload for double linked list

Question

I have realized Double Linked List. And now i need to overload == operator.

dll.cpp:67:17: error: expected expression if ([ind] != sp[ind]) {

The problem i don't understand how to overload == operator if only one parameter is given. I mean if i write bool operator ==(DLL sp1, DLL sp2){} compiler says error: overloaded 'operator==' must be a binary operator (has 3 parameters)

#include<iostream>
#include<string>
using namespace std;

template<typename T>
class DLL {
public:
    DLL(){
        size = 0;
        head = nullptr;
        tail = nullptr;
    }
    T operator [](int ind) {
        int counter = 0;
        T res = T();
        Node *cur = this->head;
        while(cur != nullptr) {
            if(counter == ind) {
                res = cur->data;
            }
            cur = cur->next;
            counter++;
        }
        return res;
    }
    bool operator ==(DLL<int> sp){
        bool isequal = true;
        for(int ind = 0; ind < sp.length(); ind++){
            if ([ind] != sp[ind]) {
                isequal = false;
            }
        }
        return isequal;

    }
    void clear() {
        while(size != 1)
            pop_front();
        delete tail;
        size--;
    }
    int length() {return size;}
    }
private:
    class Node{
    public:
        T data;
        Node *next;
        Node *prev;
        Node(T data = T(), Node *prev= nullptr, Node *next = nullptr) {
            this->data = data;
            this->next = next;
            this->prev = prev;
        }
    };
    int size;
    Node *head;
    Node *tail;
};

Answer 1

The way you have it defined as a member function (and it only takes list of int for some reason (you should probably remove the <int>).

bool operator ==(DLL<int> sp);   // There is a small issue in that you
                                 // passing by value and thus causing a copy.

                                 // Another issue with this is that it should
                                 // probably marked "const" to indicate state
                                 // is not changed by the call.

When the compiler see's this.

list1 == list2

This is simply syntactic sugar for:

list1.operator==(list2);

Thus is why you only need one parameter when you declare it as a member function. The alternative is to declare it as a friend function.

friend bool operator ==(DLL<T> const& lhs, DLL<T> const& rhs);

In this case it is a free standing function. When the compiler sees:

list1 == list2

This is syntactic sugar for:

operator==(list1, list2)

The problem was that you were defining a member function with two parameters. The left hand side is the class object and then you were expecting two objects on the right hand side (but the == operator only has one place on the right). That is why it is complaining about three parameters.

So the real question is should it be a member or a friend.

It does not matter here.

There are situations where it "can".

Example: If your class contains a single argument constructor (lets say you could create a list from an integer) and you use a member operator==()

 DLL<int>    list;

 if (list == 5) {
 }

This will now compile. Because your member operator uses a parameter and the compiler can convert an integer into the DLL parameter using a single argument constructor.

The counter argument to this is that normally you don't want automatic conversions of your type so you should mark single argument constructors as explicit to prevent this.

So:

If you class can automatically be created via a one argument constructor (most cases this is not true but it can be).

Then you should prefer a friend function version.

otherwise it does not matter and I would probably fall towards the member function.

Answer 2

A comparison operator is a binary operator that treats both the operands equally, it is advisable to make it a friend function and not a member.

So the declaration for the function would change to

friend bool operator ==(const DLL<int> & lhs, const DLL<int> & rhs);

You can choose to define it inside or outside the class.

Read here on when you need to make an operator member vs non-member.

Answer 3

You're doing the right thing for the most part.

The problem that is causing this error:

dll.cpp:67:17: error: expected expression if ([ind] != sp[ind]) {

is that you actually want to do this instead:

*this[ind] != sp[ind]

Also, there appears to be an extra } right here:

int length() {return size;}
} // <- not exactly sure what that's about, but I don't think you need it.