PV024arr2DDynMagic

#include <iostream>

//int max(int a, int b)
//{
//  return a > b ? a : b;
//}
//
//double max(double a, double b)
//{
//  return a > b ? a : b;
//}
//
//char max(char a, char b)
//{
//  return a > b ? a : b;
//}
//template <typename T>
//T max(T a, T b)
//{
//  return a > b ? a : b;
//}
//
//int max(int a, int b)
//{
//  return a > b ? a : b;
//}
//
//char max(char a, char b)
//{
//  return a > b ? a : b;
//}
//
//double max(double a, double b)
//{
//  return a > b ? a : b;
//}
//
//max(1, 3);
//max('a', 'z');
//max(5, 7);
//max(1, 'a');
//max<double>('a', true);

template <typename T>
T* createArr(int xSize)
{
    return new T[xSize];
}

template <typename T>
void deleteArr(T* arr)
{
    delete[] arr;
}


template <typename T>
T** createArr2D(int ySize, int xSize)
{
    T** container{ new T * [ySize] };

    for (int y{ 0 }; y < ySize; ++y)
    {
        container[y] = new T[xSize];
    }

    return container;
}

template <typename T>
void deleteArr2D(T** container, int ySize)
{
    for (int y{ 0 }; y < ySize; ++y)
    {
        delete[] container[y];
    }
    delete[] container;
}

template <typename T>
T** createArr2DLinear(int ySize, int xSize)
{
    T** container{ new T * [ySize] };
    T* lineArr{ new T[ySize * xSize] };
    for (int y{ 0 }; y < ySize; ++y)
    {
        container[y] = lineArr + (xSize * y);
    }
    return container;
}

template <typename T>
void deleteArr2DLinear(T** container)
{
    delete[] container[0];
    delete[] container;
}

template <typename T>
void fillArr2D(T** container, int ySize, int xSize)
{
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            container[y][x] = rand() % 10;
        }
    }
}

template <typename T>
void printArr2D(T** container, int ySize, int xSize)
{
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            std::cout << container[y][x] << '\t';
        }
        std::cout << '\n';
    }
}

template <typename T>
T max(T a, T b)
{
    return a > b ? a : b;
}

int main()
{
    double* ptrExt{};
    {

        double* ptrD{ new double[100000] };
        ptrExt = ptrD;
    }
    // work with dyn memory

    delete[] ptrExt;

    //int numI{ 42 };//[100][][][]
    //float numF{ 42.0 };//[300][][][]
    //bool flag{ true }; //[400]

    //void* ptrXZ;
    //int* ptrInt;
    //float* ptrFloat;


    //ptrInt = &numI;
    //ptrFloat = &numF;

    ////ptrXZ = &flag;
    //ptrXZ = &numI;
    //std::cout << *(float*)ptrXZ << '\n';
    //ptrXZ = &numF;
    //std::cout << *(int*)ptrXZ << '\n';

    //return 0;
    //int arr[5]{ 1,2,3,4,5 };
    ////[100][][][](1) [][][][](2) [108][][][](3) [][][][](4) [][][][](5)

    //int* ptrI{ arr + 2 }; // arr -> int* const arr <- 100
    //// 100 + 2 -> 100 + 2 * sizeof(int) -> 100 + 2 * 4 -> 108
    //std::cout << *ptrI << '\n';

    //return 0;
    //char(*fPtr)(char, char) { max<char> };
    int ySize{ 3 };
    int xSize{ 3 };

    int** arr2D{ createArr2DLinear<int>(ySize, xSize) };

    fillArr2D(arr2D, ySize, xSize);
    printArr2D(arr2D, ySize, xSize);

    std::cout << '\n';

    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            if (x == y)
            {
                arr2D[y][x] = 33;
            };
        }
    }
    arr2D[1][2] = 444;

    printArr2D(arr2D, ySize, xSize);

    deleteArr2DLinear(arr2D);

    return 0;
}