2.4/1

#include<iostream>
#include<string>
using namespace std;
/*Разработать шаблонный класс MultiSet – множество с дубликатами.
Класс должен содержать конструктор по умолчанию, основной конструктор и конструктор
копирования.
Перегрузить в этом классе операторные функции, которые обеспечивают ввод/вывод элементов
класса (>>, <<), ,
а также операторную функцию присваивания. Кроме этого перегрузить операторные функции + и
+=,
которые вычисляют объединение двух множеств. Создать с помощью этого класса множество
целых чисел.*/
template <typename T>
class deneme {
    T* data;
    int index;
public:
    deneme<T>() : index(0) {
        data = new T[100];
    };
    deneme<T>(int length)
    {
        data = new T[length];
        index = length;
    }
    ~deneme()
    {
        delete[] data;
    }
    void ekle(T y)
    {
        this->data[this->index] = y;
        this->index++;
        //data[index++] = y;
    }
    bool set(T t) {
        if (t < index)
            return true;
        else
            return false;
    }
    const T* getData()const { return data; }
    int getİdex() { return index; }
    void setİndex(int index) {
        this->index = index;
    }
    deneme<T>(const deneme<T>& c) {
        index = c.index;
        data = new T[index];
        for (int i = 0; i < index; i++) {
            data[i] = c.data[i];
        }
    }


    deneme operator+(const T x) {
        deneme<T> temp;
        for (int i = 0; i < index; i++) {
            temp.ekle(data[i] + x);
        }
        return temp;
    }
    deneme operator+(const deneme<T>& a) {
        deneme<T> temp;
        for (int i = 0; i < index; i++) {
            temp.ekle(data[i] + a.data[i]);
        }
        return temp;
    }
    deneme<T>& operator=(deneme<T>& b) {
        delete[] data;
        index = b.index;
        data = new T[index];
        for (int i = 0; i < index; i++) {
            data[i] = b.data[i];
        }
        return *this;
    };
    template <typename T> friend void operator+=(deneme<T>& a, const deneme<T>& b);
    template <typename T> friend ostream& operator << (ostream& os, const deneme<T>& obj1);

    T& operator[](const int boy) {
        return data[boy];
    }

    void print() {
        for (int i = 0; i < index; i++) {
            cout << data[i] << " ";
        }
        cout << endl;
    }
};
template <typename T>
bool operator == (const deneme<T>& d1, const deneme<T>& d2) {
    if (d1.index == d2.index)
    {
        return true;
    }
    else
    {
        return false;
    }

}
template <typename T>

void operator+=(deneme<T>& a, const deneme<T>& b) {
    int c = a.index + b.index;
    T* temp = new T[c];
    for (int i = 0, j = 0; i < c; i++) {
        if (i >= b.index)
        {
            temp[i] = b.data[j];
            j++;
        }
        else
        {
            temp[i] = a.data[i];
        }
    }


    a.data = temp;
    a.index = c;
    //delete[] a.data;
    //temp = a.data;
    //return a;
}
template <typename T>
ostream& operator << (ostream& os, const deneme<T>& obj1) {
    for (int i = 0; i < obj1.index; i++)
    {
        os << obj1.data[i] << ' ';
    }
    return os;
}
template <typename T>
istream& operator >> (istream& ob, deneme<T>& obj2) {
    for (int i = 0; i < obj2.index; i++)
    {
        ob >> obj2.data[i];
    }
    return ob;
}
int main() {
    int x;
    cout << "x:";
    cin >> x;
    deneme<int> v1, v2;
    v1.ekle(3);
    v1.ekle(2);
    v1.ekle(10);
    cout << "v1-    \t " << v1 << endl;
    v2.ekle(55);
    v2.ekle(8);
    v2.ekle(9);
    cout << "v2-    \t" << v2 << endl;
    deneme<int>v3 = v1;
    cout << "v3- \t" << v3 << endl;
    cout << "v3 + v2- " << v3 + v2 << endl;
    v3 += v2;
    cout << "v3 += v2- " << v3 << endl;

    cout << "v2 + " << x << " - " << v2 + x;
    return 0;
}