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

template <typename T>
class Vector {
private:
    size_t dimensions;
    T* data;
public:
    Vector<T>(size_t dimensions) :
        dimensions(dimensions), data(new T[dimensions] ()) {}
    virtual ~Vector<T>() {
        if (data) delete[] data;
    }

    size_t size() const {
        return dimensions;
    }

    const T& at(size_t index) const {
        return data[index];
    }

    void delete_data() {
        if (data) delete[] data;
    }
    T & operator[](size_t index) { return data[index]; }

    Vector<T> operator=(Vector<T> &vector) {
        data = new T[vector.size()];
        dimensions = vector.size();
        for (size_t i = 0; i < vector.size(); i++) {
            data[i] = vector[i];
        }
        vector.delete_data();
        return *this;
    }
    /*Vector<T>(const Vector<T>& copied) {
        dimensions = copied.dimensions();
        this = new Vector<T>(dimensions);

        for (size_t i = 0; i < dimensions; i++) {
            data[i] = copied[i];
        }
    }*/
    friend T& operator+(const Vector<T>& a, const Vector<T>& b);
    friend bool operator==(const Vector<T>& a, const Vector<T>& b);
    friend bool operator!=(const Vector<T>& a, const Vector<T>& b);
};

                /*===============================
                ==========Operatory=============
                ===============================*/
template <typename T>
T & operator+(const Vector<T>& a, const Vector<T>& b) {
    Vector<T> c(a.size());
    for (size_t i = 0; i < a.size(); i++) {
        c[i] = a[i] + b[i];
    }
    return c;
}

template <typename T>
bool operator==(const Vector<T>& a, const Vector<T>& b) {
    if (&a == &b) return true;
    if (a.size() != b.size())
        return false;
    for (size_t i = 0; i < a.size(); i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

template <typename T>
bool operator!=(const Vector<T>& a, const Vector<T>& b) {
    if (&a != &b) return true;
    if (a.size() != b.size())
        return true;
    for (size_t i = 0; i < a.size(); i++) {
        if (a[i] == b[i]) return false;
    }
    return true;
}

template <typename T>
ostream & operator<< (ostream &result, Vector<T> &out) {
    for (size_t i = 0; i < out.size(); i++) {
        result << out[i] << endl;
    }
    return result;
}
/*===============================
==========Funkcje================
=================================*/
template<typename T>
Vector<T> add(const Vector<T>& a, const Vector<T>&b) {
    Vector<T> c(a.size());
    for (size_t i = 0; i < a.size(); i++) {
        c[i] = a[i] + b[i];
    }
    return c;
}

template<typename T>
bool equals(const Vector<T>& a, const Vector<T>& b) {
    if (&a == &b) return true;
    if (a.size() != b.size())
        return false;
    for (size_t i = 0; i < a.size(); i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}
int main()
{
    Vector<int> v1(10);

    for (size_t i = 0; i < 10; i++) {
        v1[i] = i+1;
    }
    cout << v1;

    Vector<int> v2(11);
    v2 = v1;

    //cout << v2;
}