avr39ripe

cppDynArrOperator=ListTask

Jul 28th, 2021
508
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2.  
  3. template <typename ElemType>
  4. class DynArray
  5. {
  6.     ElemType* arr;
  7.     size_t size;
  8. public:
  9.     DynArray(size_t sizeP)
  10.         : arr{ new ElemType[sizeP] {} }, size{ sizeP }
  11.     {
  12.         std::cout << "DynArr constructed for " << size
  13.             << " elements, for " << this << '\n';
  14.     }
  15.     explicit DynArray(const std::initializer_list<ElemType>& list)
  16.         : DynArray(list.size())
  17.     {
  18.         //auto maxListIdx{ list.size() };
  19.         //for (size_t i{ 0 }; i < maxListIdx; ++i)
  20.         //{
  21.         //  *(arr + i) = *(list.begin() + i);
  22.         //}
  23.  
  24.         auto arrElem{ arr };
  25.         for (const auto& initElem : list)
  26.         {
  27.             *arrElem++ = initElem;
  28.         }
  29.  
  30.         std::cout << "Initialiser list constructor!\n";
  31.     }
  32.     DynArray() : DynArray(5) {}
  33.     DynArray(const DynArray& object)
  34.         : arr{ new ElemType[object.size] }, size{ object.size }
  35.     {
  36.         for (size_t i{ 0 }; i < size; ++i)
  37.         {
  38.             arr[i] = object.arr[i];
  39.         };
  40.         std::cout << "DynArr copy constructed for "
  41.             << size << " elements, for " << this
  42.             << '\n';
  43.     }
  44.  
  45.     DynArray(DynArray&& object)
  46.         : arr{ object.arr }, size{ object.size }
  47.     {
  48.         object.arr = nullptr;
  49.         object.size = 0;
  50.  
  51.         std::cout << "DynArr move constructed for "
  52.             << size << " elements, for " << this
  53.             << '\n';
  54.     }
  55.  
  56.     DynArray& operator=(const DynArray& object)
  57.     {
  58.         // проверка на самоприсваивание
  59.         if (!(this == &object))
  60.         {
  61.             /*  проверяем на невозможность "переиспользовать" блок
  62.                 памяти, выделенный под имеющийся массив */
  63.             if (size != object.size)
  64.             {
  65.                 /* в случае невозможности "переиспользования"
  66.                 необходимо освободить память, УЖЕ занимаемую
  67.                 элементами текущего динамического массива */
  68.                 delete[] arr;
  69.                 /*  выделяем новый блок памяти согласно
  70.                     размера копируемого массива */
  71.                 arr = new ElemType[object.size];
  72.             }
  73.             size = object.size;
  74.             /*  Следующим циклом копируем элементы
  75.                 из оригинального блока памяти во вновь
  76.                 выделенный.*/
  77.             for (size_t i{ 0 }; i < size; ++i)
  78.             {
  79.                 arr[i] = object.arr[i];
  80.             };
  81.         }
  82.  
  83.         std::cout << "DynArr copy assigned for "
  84.             << size << " elements, for " << this
  85.             << '\n';
  86.  
  87.         return *this;
  88.     }
  89.  
  90.     DynArray& operator=(DynArray&& object)
  91.     {
  92.         if (!(this == &object))
  93.         {
  94.             delete[] arr;
  95.             arr = object.arr;
  96.             size = object.size;
  97.  
  98.             object.arr = nullptr;
  99.             object.size = 0;
  100.         }
  101.  
  102.         std::cout << "DynArr move assigned for "
  103.             << size << " elements, for " << this
  104.             << '\n';
  105.         return *this;
  106.     }
  107.  
  108.  
  109.     int getElem(size_t idx)const { return arr[idx]; }
  110.     void setElem(size_t idx, ElemType val) { arr[idx] = val; }
  111.  
  112.     ElemType& operator[](size_t idx) { return arr[idx]; }
  113.     const ElemType& operator[](size_t idx)const { return arr[idx]; }
  114.  
  115.  
  116.     ElemType* begin() { return arr; }
  117.     ElemType* end() { return arr + size; }
  118.     void print()const;
  119.  
  120.     void randomize();
  121.  
  122.     ~DynArray()
  123.     {
  124.         std::cout << "Try to free memory from DynArray for"
  125.             << arr << " pointer\n";
  126.         if (arr)
  127.         {
  128.             delete[] arr;
  129.         }
  130.         else
  131.         {
  132.             std::cout << "NO DELETE MEMORY!NULLPTR FOUND!\n";
  133.         }
  134.         std::cout << "DynArr destructed for " << size
  135.             << " elements, for " << this << '\n';
  136.     }
  137.     template <typename ElemType>
  138.     friend std::ostream& operator<<(std::ostream& out, const DynArray<ElemType>& object);
  139.     template <typename ElemType>
  140.     friend std::istream& operator>>(std::istream& in, const DynArray<ElemType>& object);
  141.  
  142. };
  143.  
  144. template <typename ElemType>
  145. void DynArray<ElemType>::print()const
  146. {
  147.     if (!size and !arr) { std::cout << "[EMPTY]\n"; return; }
  148.  
  149.     for (int i{ 0 }; i < size; ++i)
  150.     {
  151.         std::cout << arr[i] << ' ';
  152.     }
  153.     std::cout << '\n';
  154. }
  155.  
  156. template <typename ElemType>
  157. void DynArray<ElemType>::randomize()
  158. {
  159.     for (int i{ 0 }; i < size; ++i)
  160.     {
  161.         arr[i] = rand() % 10;
  162.     }
  163. }
  164.  
  165. template <typename ElemType>
  166. DynArray<ElemType> arrayFactory(int arrSize)
  167. {
  168.     DynArray<ElemType> arrObject{ arrSize };
  169.     arrObject.randomize();
  170.     return arrObject;
  171. }
  172.  
  173.  
  174.  
  175. template <typename ElemType>
  176. std::ostream& operator<<(std::ostream& out, const DynArray<ElemType>& object)
  177. {
  178.     if (!object.size and !object.arr) { out << "[EMPTY]\n"; return out; }
  179.  
  180.     for (int i{ 0 }; i < object.size; ++i)
  181.     {
  182.         out << object.arr[i] << ' ';
  183.     }
  184.     out << '\n';
  185.  
  186.     return out;
  187. }
  188.  
  189. template <typename ElemType>
  190. std::istream& operator>>(std::istream& in, const DynArray<ElemType>& object)
  191. {
  192.     if (!object.size and !object.arr) { std::cout << "[EMPTY]\n"; return in; }
  193.  
  194.     std::cout << "Enter array elements one by one\n";
  195.     for (int i{ 0 }; i < object.size; ++i)
  196.     {
  197.         in >> object.arr[i];
  198.     }
  199.  
  200.     return in;
  201. }
  202.  
  203. int main()
  204. {
  205.     //const int arrSize{ 5 };
  206.     //int arr[arrSize]{ 11,12,13,14,15 };
  207.  
  208.     //for (auto el : arr)
  209.     //{
  210.     //  std::cout << el << ' ';
  211.     //}
  212.     //std::cout << '\n';
  213.  
  214.     //return 0;
  215.  
  216.     DynArray<float> ar1{ 36.6,35.4,37.0,40.5, 42.0 };
  217.     //DynArray<float> ar1{ 7 };
  218.  
  219.     //ar1 = { 2, 11.2, 15.4 };
  220.  
  221.     //{ 36.6,35.4,11.2,15.4, 42.0 };
  222.  
  223.     //ar1 = { 2, 1, 2,3,4,5,6 };
  224.  
  225.     //{ 36.6,35.4,1,2, 3 };
  226.  
  227.     for (const auto& el : ar1)
  228.     {
  229.         std::cout << el << ' ';
  230.     }
  231.     std::cout << '\n';
  232.  
  233.     //std::initializer_list
  234.     //ar1[0] = 36.6;
  235.     //ar1[1] = 35.4;
  236.     //ar1[2] = 37.0;
  237.     //ar1[3] = 40.5;
  238.  
  239.     //ar1 = arrayFactory(8);
  240.     ////ar1.print();
  241.     //std::cout << ar1 << '\n';
  242.  
  243.     //DynArray ar2{ std::move(ar1)};
  244.     //
  245.     ////ar1.print();
  246.     std::cout << ar1 << '\n';
  247.  
  248.     //std::cin >> ar1;
  249.  
  250.     //std::cout << ar1 << '\n';
  251.     /*ar1 = arrayFactory(2);
  252.     ar1.print();
  253.     */
  254.     return 0;
  255.  
  256. }
RAW Paste Data