cppDynArrayInputOutput

#include <iostream>

class DynArray
{
    int* arr;
    int size;
public:
    DynArray(int sizeP)
        : arr{ new int[sizeP] {} }, size{ sizeP }
    {
        std::cout << "DynArr constructed for " << size
            << " elements, for " << this << '\n';
    }
    DynArray() : DynArray(5) {}
    DynArray(const DynArray& object)
        : arr{ new int[object.size] }, size{ object.size }
    {
        for (int i{ 0 }; i < size; ++i)
        {
            arr[i] = object.arr[i];
        };
        std::cout << "DynArr copy constructed for "
            << size << " elements, for " << this
            << '\n';
    }

    DynArray(DynArray&& object)
        : arr{object.arr}, size{ object.size }
    {
        object.arr = nullptr;
        object.size = 0;

        std::cout << "DynArr move constructed for "
            << size << " elements, for " << this
            << '\n';
    }

    DynArray& operator=(const DynArray& object)
    {
        // проверка на самоприсваивание
        if (!(this == &object))
        {
            /*  проверяем на невозможность "переиспользовать" блок
                памяти, выделенный под имеющийся массив */
            if (size != object.size)
            {
                /* в случае невозможности "переиспользования"
                необходимо освободить память, УЖЕ занимаемую
                элементами текущего динамического массива */
                delete[] arr;
                /*  выделяем новый блок памяти согласно
                    размера копируемого массива */
                arr = new int[object.size];
            }
            size = object.size;
            /*  Следующим циклом копируем элементы
                из оригинального блока памяти во вновь
                выделенный.*/
            for (int i{ 0 }; i < size; ++i)
            {
                arr[i] = object.arr[i];
            };
        }

        std::cout << "DynArr copy assigned for "
            << size << " elements, for " << this
            << '\n';

        return *this;
    }

    DynArray& operator=(DynArray&& object)
    {
        if (!(this == &object))
        {
            delete[] arr;
            arr = object.arr;
            size = object.size;

            object.arr = nullptr;
            object.size = 0;
        }

        std::cout << "DynArr move assigned for "
            << size << " elements, for " << this
            << '\n';
        return *this;
    }


    int getElem(int idx)const { return arr[idx]; }
    void setElem(int idx, int val) { arr[idx] = val; }

    void print()const;
    void randomize();

    ~DynArray()
    {
        std::cout << "Try to free memory from DynArray for"
            << arr << " pointer\n";
        if (arr)
        {
            delete[] arr;
        }
        else
        {
            std::cout << "NO DELETE MEMORY!NULLPTR FOUND!\n";
        }
        std::cout << "DynArr destructed for " << size
            << " elements, for " << this << '\n';
    }
    friend std::ostream& operator<<(std::ostream& out, const DynArray& object);
    friend std::istream& operator>>(std::istream& in, const DynArray& object);

};
void DynArray::print()const
{
    if (!size and !arr) { std::cout << "[EMPTY]\n"; return; }

    for (int i{ 0 }; i < size; ++i)
    {
        std::cout << arr[i] << ' ';
    }
    std::cout << '\n';
}
void DynArray::randomize()
{
    for (int i{ 0 }; i < size; ++i)
    {
        arr[i] = rand() % 10;
    }
}


DynArray arrayFactory(int arrSize)
{
    DynArray arrObject{ arrSize };
    arrObject.randomize();
    return arrObject;
}


// FunA
void funA(int& val)
{
    std::cout << "FunA() called for int&\n";
}
void funA(const int& val)
{
    std::cout << "FunA() called for const int&\n";
}
void funA(int&& val)
{
    std::cout << "FunA() called for int&&\n";
}
//FunB
void funB(int& val)
{
    std::cout << "FunB() called for int&\n";
}
void funB(const int& val)
{
    std::cout << "FunB() called for const int&\n";
}

std::ostream& operator<<(std::ostream& out, const DynArray& object)
{
    if (!object.size and !object.arr) { out << "[EMPTY]\n"; return out; }

    for (int i{ 0 }; i < object.size; ++i)
    {
        out << object.arr[i] << ' ';
    }
    out << '\n';

    return out;
}

std::istream& operator>>(std::istream& in, const DynArray& object)
{
    if (!object.size and !object.arr) { std::cout << "[EMPTY]\n"; return in; }

    std::cout << "Enter array elements one by one\n";
    for (int i{ 0 }; i < object.size; ++i)
    {
        in >> object.arr[i];
    }

    return in;
}

int main()
{
    //int val{ 33 };
    //const int cVal{ 26 };
    //funA(val);
    //funA(cVal);
    //funA(100 + 500);
    //funB(val);
    //funB(cVal);
    //funB(100 + 500);
    DynArray ar1{4};
    //ar1 = arrayFactory(8);
    ////ar1.print();
    //std::cout << ar1 << '\n';

    //DynArray ar2{ std::move(ar1)};
    //
    ////ar1.print();
    std::cout << ar1 << '\n';

    std::cin >> ar1;

    std::cout << ar1 << '\n';
    /*ar1 = arrayFactory(2);
    ar1.print();
    */
    return 0;

}