Создание класса Array

#include<iostream>
#include <ctime>
 
using namespace std;
 
class Array
{
private:
    int *arr;
    int N;
public:
    Array() //конструктор без параметров
    {
        N = 1;
        arr = new int[N];
        for (int i = 0; i<N; i++)
            arr[i] = 0;
    }
    Array(int n) //конструктор с одним параметром
    {
        N = n;
        arr = new int[N];
        set();
    }
 
    Array (const Array & source) //конструктор копирования
    {
        N = source.N;
        arr = new int[N];
        for (int i = 0; i<N; i++)
            arr[i] = source.arr[i];
    }
 
    ~Array() //деструктор
    {
        delete[]arr; //освобождение памяти
    }
    int getsize() //возвращение размера массива
    {
        return N;
    }
 
    void print() //показать массив
    {
        for (int i = 0; i<N; i++)
            cout << arr[i] << "  ";
        cout << endl;
    }
 
    void set() //ввод случайных элементов массива
    {
        srand(time(0));
        for (int i = 0; i<N; i++)
            arr[i] = rand() % 100;
    }
 
 
    void sort() //сортировка массива по возрастанию
    {
        int temp; // переменные для хранения мин-ного значения и индекса массива
        for (int i = 0; i<N; i++)
        {
            temp = arr[i]; //инициализируем врем. переменную
            for (int j = i; j<N; j++)
                if (temp>arr[j])//находим минимальный элемент
                {
                    temp = arr[j]; //делаем перестановку
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
        }
    }
    int max()
    {
        sort();
        return arr[N - 1];
    }
    int min()
    {
        sort();
        return arr[0];
    }
};
 
int main()
{
    setlocale(LC_CTYPE, "rus");
    int n;
    cout << "Введите размер массива: ";
    cin >> n;
    Array array(n);
    cout << "Массив" << endl;
    array.print();
    array.sort();
    array.print();
    cout << "Max=" << array.max() << " Min=" << array.min() << endl;
 
    system("pause");
    return 0;
}

#include <iostream>
#include <cstdlib>
 
template<typename T>
class tarray {
private:
    T*     arr;
    size_t num;
public:
    tarray(void):arr(nullptr), num(0){}
    tarray(const tarray& a):arr(nullptr), num(0){
        *this = a;
    }
    tarray(tarray&& a):arr(nullptr), num(0){
        *this = std::forward<decltype(a)>(a);
    }
    explicit tarray(size_t n, const T& v = T()):arr(nullptr), num(0){
        resize(n, v);
    }
    ~tarray(){ clear(); }
public:
    //изменение размера
    void resize(size_t n, const T& v = T()){
        clear();
        arr  = new T[n];
        T* e = arr + n;
        for(T* p = arr; p != e; ++p)
            *p = v;
        num = n;
    }
 
    //поиск мин/макс
    template<typename Cmp>
    T* find_element(Cmp cmp){
        T* i = arr, *e = arr + num;
        T* p = i;
        for(; i != e; ++i){
            if(cmp(*i, *p))
                p = i;
        }
        return p;
    }
 
    //пирамидальная сортировка
    template<typename Cmp>
    void sort(Cmp cmp){
        if(num <= 1)
            return;
 
        for(size_t i = num / 2 + 1; i > 0; --i) 
            _heapify(i - 1, cmp, num);
 
        for(size_t j = num - 1; j > 0; --j){
            std::swap(arr[0], arr[j]);
            _heapify(0, cmp, j);
        }
    }
 
    tarray& operator = (const tarray& a){
        if(this != &a){
            resize(a.num);
            T* e = a.arr + a.num;
            T* d = arr;
            for(T* p = a.arr; p != e; ++p)
                *d++ = *p;
        }
        return *this;
    }
 
    tarray& operator = (tarray&& a){
        if(this != &a){
            clear();
            arr = a.arr;
            num = a.num;
            a.arr = nullptr;
            a.num = 0;
        }
        return *this;
    }
 
    T& operator [] (size_t i){ return arr[i]; }
    const T& operator [] (size_t i) const { return arr[i]; }
 
    void clear(void){
        if(arr != nullptr)
            delete[] arr;
        arr = nullptr;
        num = 0;
    }
 
    size_t size(void) const { return num; }
    T* begin(void) { return arr; }
    T* end(void) { return arr + num; }
    const T* cbegin(void) const { return arr; }
    const T* cend(void) const { return arr + num; }
private:
    template<typename Cmp>
    void _heapify(size_t i, Cmp cmp, size_t cnt){
        size_t l, r, h;
        while(1){
            l = (i << 1) + 1;
            r = l + 1;
            if((l < cnt) && cmp(arr[i], arr[l]))
                h = l;
            else
                h = i;
 
            if((r < cnt) && cmp(arr[h], arr[r]))
                h = r;
 
            if(h != i){
                std::swap(arr[i], arr[h]);
                i = h;
            } else
                break;
        }
    }
};
 
int main(void){
    tarray<int> arr(10);
    for(size_t i = 0; i < arr.size(); ++i)
        arr[i] = rand() % 10;
 
    //минимум
    int* _min = arr.find_element([](int a, int b) { return (a < b); });
    if(_min != arr.end())
        std::cout << "min: " << *_min << std::endl;
 
    //максимум
    int* _max = arr.find_element([](int a, int b) { return (a > b); });
    if(_max != arr.end())
        std::cout << "max: " << *_max << std::endl;
 
    //сортируем по возрастанию
    arr.sort([] (int a, int b) { return (a < b); });
    for(size_t i = 0; i < arr.size(); ++i)
        std::cout << arr[i] << ' ';
    std::cout << std::endl;
 
    //сортируем по убыванию
    arr.sort([] (int a, int b) { return (a > b); });
    for(size_t i = 0; i < arr.size(); ++i)
        std::cout << arr[i] << ' ';
    arr.clear();
    std::cin.get();
    return 0;
}

        Array(Array & copy) //конструктор копирования
        {
            arr = copy.arr;
            N = copy.N;
        }

        Array(const Array &copy)
        {
            arr = new int[copy.N];
            N = copy.N;
            memcpy(arr, copy.arr, sizeof(int) * N);
        }

   int max()
    {
        sort();
        return arr[N - 1];
    }
    int min()
    {
        sort();
        return arr[0];
    }

#include "pch.h"
#include <windows.h>
#include <string>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <iomanip>
#include <fstream>
#include <malloc.h>
#include <utility>
#include <cassert>
 
using namespace std;
const int NotUsed = system("color 17");
#pragma warning(disable : 4996) // Без этого не работали функции strcpy 
 
class Array
{
private:
    
public:
    int** DM;
    int rows;
    int cols;   
 
    Array()
    {
        cout << "\n Это конструктор по умолчанию \n";
        rows = 3;
        cols = 6;
        DM = new int*[rows];
        for (int i = 0; i < rows; i++)
            DM[i] = new int[cols];  
        
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                DM[i][j] = rand() % 10;             
            }           
        }
    }
 
    Array(int a, int b)
    {
        int rows = a;
        int cols = b;
        cout << "\n Это конструктор с пареметрами (размер массива) \n";          
        DM = new int* [rows];
        for (int i = 0; i < rows; i++)
            DM[i] = new int[cols];
 
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                DM[i][j] = rand() % 10;
            }
        }       
    }
 
    void Show()
    {
        cout << "\n Это метод Show \n";
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                cout << " " << DM[i][j];
            }
            cout << endl;
        }
    }   
 
    ~Array()
    {
        cout << "\n Это деструктор \n";
        for (int i = 0; i < rows; i++)
            delete[] DM[i];
        delete []DM;
 
    }
};
 
void main()
{
    RECT lpRectToolBar;
    HWND console = GetConsoleWindow();
    RECT ConsoleRect;
    GetWindowRect(console, &ConsoleRect);
    MoveWindow(console, ConsoleRect.left, ConsoleRect.top, 800, 1000, TRUE);
 
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    Array MAS1;
    MAS1.Show();    
 
    Array MAS3(10,20);
    MAS3.Show();    
}

Array(int a, int b)
 {
 rows = a;
 cols = b;