Simple SmartPointer demo

template <typename T>
class SMARTPOINTER {
public:
    T* ptr;
private: size_t size;
public:
    SMARTPOINTER() :size{1}{
        ptr = new T[1];
    }
    SMARTPOINTER(size_t Size) {
        ptr = new T[Size];
        size = Size;
    }
    SMARTPOINTER(T* p, size_t Size) {
        ptr = (T*)realloc(p, Size * sizeof(T));
    }
    SMARTPOINTER(SMARTPOINTER& s) {
        this->copy(s);
    }
    ~SMARTPOINTER() {
        delete[] ptr;
    }
    void resize(size_t Size) {
        auto a = (T*)realloc(ptr, sizeof(T) * Size);
        if (a) { ptr = a; }
        size = Size;
    }
    T& operator[](size_t index) {
        return ptr[index];
    }
    T& operator*() {
        return *ptr;
    }
    bool operator==(T t) {
        return *ptr == t ? true : false;
    }
    bool operator!=(T t) {
        return *ptr != t ? true : false;
    }
    bool operator ==(T* t) {
        return ptr == t ? true : false;
    }
    bool operator !=(T* t) {
        return ptr != t ? true : false;
    }
    bool operator==(SMARTPOINTER& other) {
        if (ptr == other.ptr) {
            return true;
        }
        return false;
    }
    bool operator!=(SMARTPOINTER& other) {
        if (ptr != other.ptr) {
            return true;
        }
        return false;
    }
    void operator=(T* t) {
        delete[] ptr;
        ptr = t;
    }
    void operator=(SMARTPOINTER& other) {
        this->copy(other);
    }
    void operator=(T t) {
        *ptr = t;
    }
    friend ostream& operator<<(ostream& o, SMARTPOINTER& sp) {
        for (auto i = 0; i < sp.Size(); i++) {
            o << sp.ptr[i] << '\n';
        }
        return o;
    }
    size_t Size() {
        return size;
    }

private:

    void copy(SMARTPOINTER& s) {
        this->resize(s.Size());
        memcpy_s(ptr, size* sizeof(T), s.ptr, s.size*sizeof(T));
    }
    SMARTPOINTER& copy() {
        SMARTPOINTER<T> s;
        s.resize(size);
        memcpy_s(s.ptr, s.size*sizeof(T), ptr, size*sizeof(T));
        return s;
    }

};

int main() {

    SMARTPOINTER<int> a;
    SMARTPOINTER<int> b;
    *a = 1;
    a.resize(5);

    for (int i = 1; i < 5; i++) {
        a[i] = i + 10;
    }
    b = a;
    for (int i = 0; i < b.Size(); i++) {
        cout << b[i] << "\n";
    }
    SMARTPOINTER<int> c;
    int* d = new int[1];
    *d = 8;
    c = d;
    cout << *c<<"\n";

    b.resize(20);
    for (int i = 0; i < b.Size(); i++) {
        b[i] = i + 25 + i * i;
    }
    cout << b;
}