Использование шаблонов (параметризированных) классов. Дополнить определение класса заданными перегруженными операциями

#include <iostream>
#include <string>
using namespace std;
 
template <class T>
class SetArray {// класс
private://приватные, закрытые поля класса
    T* arr; //указатель на начало массива;
    int maxSize; //максимальный размер массива;
    int size; //текущий размер массива.
public://открытые поля и методы класса
    SetArray() { //конструктор по умолчанию
        maxSize = 0; //присваивание значений полям класса
        size = 0;
        arr = NULL;
    }
    SetArray(int maxSize) {//другой конструктор с параметрами
        this->maxSize = maxSize;
        size = 0;
        arr = new T[maxSize];//создание массива максимальной длины
    }
    ~SetArray() {//деструктор
        delete[] arr;//освобождение памяти из под массива
    }
 
    void operator += (T item) {
        if (size < maxSize) {
            arr[size] = item;  // если размер меньше максимального
                               // добавляем новый элемент в массив
            size++;
        }
    }
 
    void operator = (SetArray& setarray) {
        maxSize = setarray.maxSize; // копируем данные из setarray в текущий массив
        free(arr); // сначала освобождаем память
        arr = (T*)calloc(this->maxSize, sizeof(T)); // выделяем новую память для элементов setarray
        for (int i = 0; i < setarray.size; i++) {
            arr[i] = setarray.arr[i]; // непосредственно копируем элементы
            ++this->size;
        }
    }
 
    bool operator == (SetArray& setchar) {
        if (size != setchar.size) return false; // сравниваем элементы по размеру
        // если равная длина, сравниваем по элементам
        for (int i = 0; i < size; i++)
            if (arr[i] != setchar.arr[i]) return false;
        return true;
    }
 
    void input(int size) {
        if (size > maxSize) return; // если есть свободная память для новых элементов 
        this->size = size;
        cout << size << ":" << endl;
        for (int i = 0; i < size; i++) {
            T item;
            cin >> item;
            arr[i] = item;
        }
    }
 
    void print() {
        for (int i = 0; i < size; i++)
            cout << arr[i] << " ";
        cout << endl;
    }
 
    friend SetArray& operator + (SetArray& s1, SetArray& s2) {
        int maxTotalSize = s1.maxSize + s2.maxSize;
        SetArray result(maxTotalSize);
        for (int i = 0; i < s1.size; i++) {
            result.arr[i] = s1.arr[i];
        }
        for (int i = 0; i < s2.size; i++) {
            result += s2.arr[i];
        }
        return result;
    }
 
    friend SetArray& operator * (SetArray& s1, SetArray& s2) {
        int mSize;
        if (s1.maxSize > s2.maxSize) {
            mSize = s1.maxSize;
        } else mSize = s2.maxSize;
        SetArray result(mSize);
        for (int i = 0; i < s1.size; i++) {
            for (int j = 0; j < s2.size; j++)
                if (s1.arr[i] == s2.arr[j])
                    result += s1.arr[i];
        }
        return result;
    }
};
 
int main() {
    SetArray<char> st(10);
    st.input(5);
    st.print();
 
    SetArray<char>  st2(10);
    st2.input(5);
    st2.print();
 
    if (st == st2) cout << "set is equal" << endl;
    else cout << "set is not equal" << endl;
 
    SetArray<char>  st1;
    st1 = st2;
    if (st1 == st2) cout << "set is equal" << endl;
    else cout << "set is not equal" << endl;
 
    SetArray<char> st3;
    st3 = st + st2;
    st3.print();
 
 
    st3 += 't';
 
 
    st3.print();
 
    SetArray<char> st4;
    st4 = st * st2;
    cout << "--------" << endl;
    st4.print();
    return 0; 
};

#include <iostream>
#include <sstream>
#include <string>
 
template<typename Iterator, typename T>
Iterator lower_bound(Iterator first, Iterator last, const T &value) {
    std::size_t count = std::distance(first, last);
 
    while (count > 0) {
        std::size_t step = count / 2;
        Iterator it = first + step;
        if (*it < value) {
            first = ++it;
            count -= step + 1;
        } else {
            count = step;
        }
    }
    return first;
 
}
 
template<typename Container, typename T>
class SetInsertIterator {
public:
 
    using self = SetInsertIterator<Container, T>;
 
    SetInsertIterator(Container &container) : container(&container) {}
 
    self &operator=(const T &value) {
        container->insert(value);
        return *this;
    }
 
    self &operator*() {
        return *this;
    }
 
    self &operator++() {
        return *this;
    }
 
    self &operator++(int) {
        return *this;
    }
 
private:
    Container *container;
};
 
template<typename T>
class Set {
public:
 
    using const_reference = const T &;
    using pointer = T *;
    using self = Set<T>;
    using iterator = T *;
    using const_iterator = const T *;
    using insert_iterator = SetInsertIterator<Set<T>, T>;
 
    explicit Set(std::size_t maxSize) : size{0}, maxSize{maxSize}, data{new T[size]} {}
 
    Set(const self &other) : size{other.size}, maxSize{other.maxSize}, data{new T[size]} {
        std::copy(other.begin(), other.end(), data);
    }
 
    self &operator=(const self &other) {
        if (this != &other) {
            size = other.size;
            maxSize = other.maxSize;
            delete[] data;
            data = new T[maxSize];
            std::copy(other.begin(), other.end(), data);
        }
        return *this;
    }
 
    virtual ~Set() {
        delete[] data;
    }
 
    iterator begin() {
        return data;
    }
 
    iterator end() {
        return data + size;
    }
 
    const_iterator begin() const {
        return data;
    }
 
    const_iterator end() const {
        return data + size;
    }
 
    bool isEmpty() const {
        return size == 0;
    }
 
    std::size_t getSize() const {
        return size;
    }
 
    iterator find(const_reference value) {
        iterator position = ::lower_bound(begin(), end(), value);
        return (position != end() && *position == value) ? position : end();
    }
 
    const_iterator find(const_reference value) const {
        const_iterator position = ::lower_bound(begin(), end(), value);
        return (position != end() && *position == value) ? position : end();
    }
 
    bool contains(const_reference value) const {
        const_iterator position = ::lower_bound(begin(), end(), value);
        return position != end() && *position == value;
    }
 
    iterator insert(const_reference value) {
        iterator position = ::lower_bound(begin(), end(), value);
        if (position != end() && *position == value) {
            return position;
        }
        for (iterator i = end(); i != position; --i) {
            *i = *(i - 1);
        }
        *position = value;
        ++size;
        return position;
    }
 
    iterator remove(iterator position) {
        iterator result = position + 1;
        for (iterator i = position; (i + 1) != data + size; ++i) {
            *i = *(i + 1);
        }
        --size;
        return result;
    }
 
    iterator remove(const_reference value) {
        iterator position = find(value);
        if (position != end()) {
            return remove(position);
        }
        return end();
    }
 
private:
    std::size_t size;
    std::size_t maxSize;
    pointer data;
};
 
template<typename Container>
typename Container::insert_iterator inserter(Container &container) {
    return typename Container::insert_iterator(container);
}
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Set<T> &s) {
    out << "[";
    for (auto i = s.begin(); i != s.end(); ++i) {
        out << *i;
        if ((i + 1) != s.end()) {
            out << ", ";
        }
    }
    return out << "]";
}
 
template<typename T>
std::istream &operator>>(std::istream &in, Set<T> &s) {
    std::string line;
    std::getline(in, line);
    std::stringstream ss(line);
    T value;
    while (ss >> value) {
        s.insert(value);
    }
    return in;
}
 
 
template<typename T>
Set<T> operator*(const Set<T> &a, const Set<T> &b) {
    Set<T> result{a.getSize() + b.getSize()};
    for (const auto &i : a) {
        if (b.contains(i)) {
            result.insert(i);
        }
    }
    return result;
}
 
template<typename T>
bool operator>(const Set<T> &a, const Set<T> &b) {
    return a.getSize() > b.getSize();
}
 
template<typename T>
Set<T> operator-(const Set<T> &a, const Set<T> &b) {
    Set<T> result{a};
    for (const auto &i : b) {
        result.remove(i);
    }
    return result;
}
 
int main() {
 
    Set<int> a(100);
    Set<int> b(100);
 
    std::cin >> a >> b;
 
    std::cout << a << std::endl << b << std::endl;
    std::cout << a << " * " << b << " = " << a * b << std::endl;
    std::cout << a << " > " << b << " = " << std::boolalpha << (a > b) << std::endl;
    std::cout << a << " - " << b << " = " << (a - b) << std::endl;
 
    return 0;
}