How to build a operator== in template class

Question

I have a assignment where I'm suppose to build template using these specifications.

ISet is a container that holds values ​​of a certain where order doesn't matter and which does not allow duplicates (or multiples). A dynamically allocated array of type T should be used as an internal data structure for the Set. The Set should inherit from the ISet interface below - this must not be modified:

template <typename T>
class ISet
{
public:
virtual bool insert (T element) = 0;
virtual bool remove (T element) = 0;
virtual int size () const = 0;
};

• insert (T element): adds elements to the set and returns true provided that
the element is not already present in the quantity (in which case the element is not added and false is returned).

• remove (T element): removes elements from the set and returns true.
If the element is missing in the quantity, false returns.

• size (): returns the number of elements in the set.
In addition to the member functions, you must implement constructor, destructor, copy constructor
and assignment operator.

And so far have I come up with this code:

#pragma once
#include <string>
#include <iostream>

using namespace std;

template <class T>
class ISet
{

public:

    virtual bool insert(T element) = 0;
    virtual bool remove(T element) = 0;
    virtual int size() const = 0;
};


#pragma once
#include "ISet.h"

template <class T>
class Set : public ISet<T>
{
public:
    Set(string name);
    ~Set();
    Set(const Set &origin);
    //Set& operator=(const Set &origin);

    bool insert(T element);
    bool remove(T element);
    int size()const;

private:
    string name;
    T *arr;
    int cap, nrOfElement;
};



template<class T>
Set<T>::Set(string name)
{
    this->name = name;
    this->cap = 10;
    this->nrOfElement = 0;
    this->arr = new T[this->cap];

}

template<class T>
Set<T>::~Set()
{
    delete[] arr;
}

template<class T>
Set<T>::Set(const Set & origin)
{
    this->nrOfElement = origin.nrOfElement;
    this->cap = origin.cap;

    arr = new T*[cap];

    for (int i = 0; i < nrOfElement; i++)
    {
        arr[i] = origin.arr[i];
    }

}

template<class T>
bool Set<T>::insert(T element)
{
    bool found = false;

    if (nrOfElement == 0)
    {
        this->arr[0] = element;
        this->nrOfElement++;
    }
    else
    {
        for (int i = 0; i < this->nrOfElement; i++)
        {
            if (this->arr[i] == element)
            {
                i = this->nrOfElement;
                found = true;
            }
        }
        if (found == false)
        {
            this->arr[nrOfElement++] = element;
        }
    }

    return found;
}

template<class T>
bool Set<T>::remove(T element)
{
    bool removed = false;

    for (int i = 0; i < this->nrOfElement; i++)
    {
        if (this->arr[i] == element)
        {
            this->arr[i] = this->arr[nrOfElement];
            nrOfElement--;
            removed = true;
        }
    }
    return removed;
}

template<class T>
int Set<T>::size() const
{
    return this->nrOfElement;
}

And my problems starts when I start to test this code by adding the different data-type we are suppose to test the template against.

#include "Set.h"
#include "ISet.h"
#include "Runner.h"

int main()
{
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    Set<string> test("test");
    test.insert("lol");
    cout << test.size();
    test.remove("lol");
    cout << test.size();

    Set<Runner> test2("test");


    getchar();
    return 0;
}

Getting the error saying that "No operator found which takes a left-hand operand type of 'Runner'. So I have to create a operator== that handles this but don't know? Runner class looks like this:

#pragma once
#include "Competitor.h"
#include <string>

using namespace std;

class Runner : public Competitor
{
public:
    Runner();
    Runner(string firstName, string lastName, int startNr);
    ~Runner();

    void addResult(int resultTime);
    int getResult() const;
    string toString() const;
    Runner *clone() const;

private:
    int resultTime;

};

#include "Runner.h"

Runner::Runner()
{
    this->resultTime = 0;
}

Runner::Runner(string firstName, string lastName, int startNr) : Competitor(firstName, lastName, startNr)
{
    this->resultTime = 0;
}


Runner::~Runner()
{
}

void Runner::addResult(int resultTime)
{
    this->resultTime = resultTime;
}

int Runner::getResult() const
{
    return this->resultTime;
}

string Runner::toString() const
{
    return (to_string(this->resultTime) + " sec");
}

Runner * Runner::clone() const
{
    return new Runner(*this);
}

How do I build a operator== that will work for this?

Answer 1

You need to add operator== to the Runner class:

bool operator==(const Runner& other) const;