avr39ripe

cppDynArrayInitListAssigmentSolution

Jul 28th, 2021
854
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.     DynArray<ElemType>& operator=(const std::initializer_list<ElemType>& param);
  109.  
  110.     int getElem(size_t idx)const { return arr[idx]; }
  111.     void setElem(size_t idx, ElemType val) { arr[idx] = val; }
  112.  
  113.     ElemType& operator[](size_t idx) { return arr[idx]; }
  114.     const ElemType& operator[](size_t idx)const { return arr[idx]; }
  115.  
  116.  
  117.     ElemType* begin() { return arr; }
  118.     ElemType* end() { return arr + size; }
  119.     void print()const;
  120.  
  121.     void randomize();
  122.  
  123.     ~DynArray()
  124.     {
  125.         std::cout << "Try to free memory from DynArray for"
  126.             << arr << " pointer\n";
  127.         if (arr)
  128.         {
  129.             delete[] arr;
  130.         }
  131.         else
  132.         {
  133.             std::cout << "NO DELETE MEMORY!NULLPTR FOUND!\n";
  134.         }
  135.         std::cout << "DynArr destructed for " << size
  136.             << " elements, for " << this << '\n';
  137.     }
  138.     template <typename ElemType>
  139.     friend std::ostream& operator<<(std::ostream& out, const DynArray<ElemType>& object);
  140.     template <typename ElemType>
  141.     friend std::istream& operator>>(std::istream& in, const DynArray<ElemType>& object);
  142.  
  143. };
  144.  
  145. template <typename ElemType>
  146. DynArray<ElemType>& DynArray<ElemType>::operator=(const std::initializer_list<ElemType>& rightList)
  147. {
  148.     int insertIndex{ 0 };
  149.     int startShift{ -1 };
  150.  
  151.     for (const auto& elem : rightList)
  152.     {
  153.         if (startShift == -1)
  154.         {
  155.             startShift = elem;
  156.             continue;
  157.         }
  158.  
  159.         if (startShift + insertIndex < size)
  160.         {
  161.             *(arr + startShift + insertIndex++) = elem;
  162.         }
  163.         else
  164.         {
  165.             std::cout << "Error! Overassigment prevented! :)\n";
  166.             break;
  167.         }
  168.     }
  169.     return *this;
  170. };
  171.  
  172. //template <typename ElemType>
  173. //DynArray<ElemType>& DynArray<ElemType>::operator=(const std::initializer_list<ElemType>& list) {
  174. //
  175. //  auto arrElem{ arr };
  176. //  auto move = *list.begin();
  177. //
  178. //  for (const auto& initElem : list)
  179. //  {
  180. //      if (initElem == move) { continue; }
  181. //      *(arrElem + (int)move++) = initElem;
  182. //  }
  183. //  return *this;
  184. //}
  185.  
  186. template <typename ElemType>
  187. void DynArray<ElemType>::print()const
  188. {
  189.     if (!size and !arr) { std::cout << "[EMPTY]\n"; return; }
  190.  
  191.     for (int i{ 0 }; i < size; ++i)
  192.     {
  193.         std::cout << arr[i] << ' ';
  194.     }
  195.     std::cout << '\n';
  196. }
  197.  
  198. template <typename ElemType>
  199. void DynArray<ElemType>::randomize()
  200. {
  201.     for (int i{ 0 }; i < size; ++i)
  202.     {
  203.         arr[i] = rand() % 10;
  204.     }
  205. }
  206.  
  207. template <typename ElemType>
  208. DynArray<ElemType> arrayFactory(int arrSize)
  209. {
  210.     DynArray<ElemType> arrObject{ arrSize };
  211.     arrObject.randomize();
  212.     return arrObject;
  213. }
  214.  
  215.  
  216.  
  217. template <typename ElemType>
  218. std::ostream& operator<<(std::ostream& out, const DynArray<ElemType>& object)
  219. {
  220.     if (!object.size and !object.arr) { out << "[EMPTY]\n"; return out; }
  221.  
  222.     for (int i{ 0 }; i < object.size; ++i)
  223.     {
  224.         out << object.arr[i] << ' ';
  225.     }
  226.     out << '\n';
  227.  
  228.     return out;
  229. }
  230.  
  231. template <typename ElemType>
  232. std::istream& operator>>(std::istream& in, const DynArray<ElemType>& object)
  233. {
  234.     if (!object.size and !object.arr) { std::cout << "[EMPTY]\n"; return in; }
  235.  
  236.     std::cout << "Enter array elements one by one\n";
  237.     for (int i{ 0 }; i < object.size; ++i)
  238.     {
  239.         in >> object.arr[i];
  240.     }
  241.  
  242.     return in;
  243. }
  244.  
  245. int main()
  246. {
  247.     //const int arrSize{ 5 };
  248.     //int arr[arrSize]{ 11,12,13,14,15 };
  249.  
  250.     //for (auto el : arr)
  251.     //{
  252.     //  std::cout << el << ' ';
  253.     //}
  254.     //std::cout << '\n';
  255.  
  256.     //return 0;
  257.  
  258.     DynArray<float> ar1{ 36.6,35.4,37.0,40.5, 42.0 };
  259.     //DynArray<float> ar1{ 7 };
  260.  
  261.     ar1 = { 2, 11.2, 15.4 };
  262.  
  263.     std::cout << ar1 << '\n';
  264.  
  265.     //{ 36.6,35.4,11.2,15.4, 42.0 };
  266.  
  267.     ar1 = { 2, 1, 2,3,4,5,6 };
  268.  
  269.     //{ 36.6,35.4,1,2, 3 };
  270.  
  271.     for (const auto& el : ar1)
  272.     {
  273.         std::cout << el << ' ';
  274.     }
  275.     std::cout << '\n';
  276.  
  277.     //std::initializer_list
  278.     //ar1[0] = 36.6;
  279.     //ar1[1] = 35.4;
  280.     //ar1[2] = 37.0;
  281.     //ar1[3] = 40.5;
  282.  
  283.     //ar1 = arrayFactory(8);
  284.     ////ar1.print();
  285.     //std::cout << ar1 << '\n';
  286.  
  287.     //DynArray ar2{ std::move(ar1)};
  288.     //
  289.     ////ar1.print();
  290.     std::cout << ar1 << '\n';
  291.  
  292.     //std::cin >> ar1;
  293.  
  294.     //std::cout << ar1 << '\n';
  295.     /*ar1 = arrayFactory(2);
  296.     ar1.print();
  297.     */
  298.     return 0;
  299.  
  300. }
RAW Paste Data