cppDynArrayInitListAssigmentSolution

#include <iostream>

template <typename ElemType>
class DynArray
{
    ElemType* arr;
    size_t size;
public:
    DynArray(size_t sizeP)
        : arr{ new ElemType[sizeP] {} }, size{ sizeP }
    {
        std::cout << "DynArr constructed for " << size
            << " elements, for " << this << '\n';
    }
    explicit DynArray(const std::initializer_list<ElemType>& list)
        : DynArray(list.size())
    {
        //auto maxListIdx{ list.size() };
        //for (size_t i{ 0 }; i < maxListIdx; ++i)
        //{
        //  *(arr + i) = *(list.begin() + i);
        //}

        auto arrElem{ arr };
        for (const auto& initElem : list)
        {
            *arrElem++ = initElem;
        }

        std::cout << "Initialiser list constructor!\n";
    }
    DynArray() : DynArray(5) {}
    DynArray(const DynArray& object)
        : arr{ new ElemType[object.size] }, size{ object.size }
    {
        for (size_t 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 ElemType[object.size];
            }
            size = object.size;
            /*  Следующим циклом копируем элементы
                из оригинального блока памяти во вновь
                выделенный.*/
            for (size_t 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;
    }

    DynArray<ElemType>& operator=(const std::initializer_list<ElemType>& param);

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

    ElemType& operator[](size_t idx) { return arr[idx]; }
    const ElemType& operator[](size_t idx)const { return arr[idx]; }


    ElemType* begin() { return arr; }
    ElemType* end() { return arr + size; }
    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';
    }
    template <typename ElemType>
    friend std::ostream& operator<<(std::ostream& out, const DynArray<ElemType>& object);
    template <typename ElemType>
    friend std::istream& operator>>(std::istream& in, const DynArray<ElemType>& object);

};

template <typename ElemType>
DynArray<ElemType>& DynArray<ElemType>::operator=(const std::initializer_list<ElemType>& rightList)
{
    int insertIndex{ 0 };
    int startShift{ -1 };

    for (const auto& elem : rightList)
    {
        if (startShift == -1)
        {
            startShift = elem;
            continue;
        }

        if (startShift + insertIndex < size)
        {
            *(arr + startShift + insertIndex++) = elem;
        }
        else
        {
            std::cout << "Error! Overassigment prevented! :)\n";
            break;
        }
    }
    return *this;
};

//template <typename ElemType>
//DynArray<ElemType>& DynArray<ElemType>::operator=(const std::initializer_list<ElemType>& list) {
//
//  auto arrElem{ arr };
//  auto move = *list.begin();
//
//  for (const auto& initElem : list)
//  {
//      if (initElem == move) { continue; }
//      *(arrElem + (int)move++) = initElem;
//  }
//  return *this;
//}

template <typename ElemType>
void DynArray<ElemType>::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';
}

template <typename ElemType>
void DynArray<ElemType>::randomize()
{
    for (int i{ 0 }; i < size; ++i)
    {
        arr[i] = rand() % 10;
    }
}

template <typename ElemType>
DynArray<ElemType> arrayFactory(int arrSize)
{
    DynArray<ElemType> arrObject{ arrSize };
    arrObject.randomize();
    return arrObject;
}



template <typename ElemType>
std::ostream& operator<<(std::ostream& out, const DynArray<ElemType>& 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;
}

template <typename ElemType>
std::istream& operator>>(std::istream& in, const DynArray<ElemType>& 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()
{
    //const int arrSize{ 5 };
    //int arr[arrSize]{ 11,12,13,14,15 };

    //for (auto el : arr)
    //{
    //  std::cout << el << ' ';
    //}
    //std::cout << '\n';

    //return 0;

    DynArray<float> ar1{ 36.6,35.4,37.0,40.5, 42.0 };
    //DynArray<float> ar1{ 7 };

    ar1 = { 2, 11.2, 15.4 };

    std::cout << ar1 << '\n';

    //{ 36.6,35.4,11.2,15.4, 42.0 };

    ar1 = { 2, 1, 2,3,4,5,6 };

    //{ 36.6,35.4,1,2, 3 };

    for (const auto& el : ar1)
    {
        std::cout << el << ' ';
    }
    std::cout << '\n';

    //std::initializer_list
    //ar1[0] = 36.6;
    //ar1[1] = 35.4;
    //ar1[2] = 37.0;
    //ar1[3] = 40.5;

    //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;

}