BBR192_2dDynArrLecture

//#include <iostream>
//
//int main()
//{
//    int sizey{ 10 };
//    int sizex{ 10 };
//
//    int** arr2d = new int* [sizey];
//
//    for (int i = 0; i < sizey; i++)
//    {
//        arr2d[i] = new int[sizex];
//    }
//
//
//
//    for (int i = 0; i < sizey; i++)
//    {
//        for (int j = 0; j < sizex; j++)
//        {
//            arr2d[i][j] = rand() % 10;
//        }
//    }
//
//    for (int i = 0; i < sizey; i++)
//    {
//        for (int j = 0; j < sizex; j++)
//        {
//            std::cout << arr2d[i][j] << ' ';
//        }
//        std::cout << '\n';
//    }
//
//    int** arr2dcopy = new int* [sizey - 1];
//    for (int i = 0; i < sizey - 1; i++)
//    {
//        arr2dcopy[i] = arr2d[i];
//    }
//    delete[]arr2d[sizey - 1];
//
//}


#include <iostream>


void printArr2d(int arr2d[][3], int ySize, int xSize)
{
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            std::cout << arr2d[y][x] << '\t';
        }
        std::cout << '\n';
    }
}

void printArr(int* arr, int xSize)
{
    for (int x{ 0 }; x < xSize; ++x)
    {
        std::cout << arr[x] << '\t';
    }
    std::cout << '\n';
}

//y = 1, x = 1 => 5 (xSize = 3)
int& lineTo2dArr(int* arr, int yIdx, int xIdx, int xSize)
{
    return *(arr + yIdx * xSize + xIdx);
}


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

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

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

    delete[] arr2d;
}

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

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

template <typename T>
void copy(T* srcB, T* srcE, T* destB, T* destE)
{
    while (srcB != srcE and destB != destE)
    {
        *destB++ = *srcB++;
    }
}

//template <typename T>
//void deleteLastLine2dArr(T**& arr2d, int& ySize)
//{
//  delete[] arr2d[ySize - 1];
//  T** tmp = new T* [--ySize];
//  //copy(arr2d, arr2d + ySize, tmp, tmp + ySize);
//  for (int y{ 0 }; y < ySize; ++y)
//  {
//      tmp[y] = arr2d[y];
//  }
//  delete[] arr2d;
//  arr2d = tmp;
//}

template <typename T>
void deleteLine2dArr(T**& arr2d, int& ySize, int lineIdx)
{
    delete[] arr2d[lineIdx];
    T** tmp = new T * [--ySize];
    for (int y{ 0 }; y < ySize; ++y)
    {
        y < lineIdx ? tmp[y] = arr2d[y] : tmp[y] = arr2d[y+1];
    }
    delete[] arr2d;
    arr2d = tmp;
}

template <typename T>
void deleteLastLine2dArr(T**& arr2d, int& ySize)
{
    deleteLine2dArr(arr2d, ySize, ySize - 1);
}

template <typename T>
void deleteFirstLine2dArr(T**& arr2d, int& ySize)
{
    deleteLine2dArr(arr2d, ySize, 0);
}

int main()
{
    int ySize{ 10 };
    int xSize{ 10 };

    int** arr2d = create2dArr<int>(ySize, xSize);
    fill2dArr(arr2d, ySize, xSize);
    print2dArr(arr2d, ySize, xSize);
    std::cout << '\n';
    deleteLine2dArr(arr2d, ySize,5);
    std::cout << "New ySize is: " << ySize << "\n\n";
    print2dArr(arr2d, ySize, xSize);
    std::cout << '\n';
    deleteLastLine2dArr(arr2d, ySize);
    std::cout << "New ySize is: " << ySize << "\n\n";
    print2dArr(arr2d, ySize, xSize);
    std::cout << '\n';
    deleteFirstLine2dArr(arr2d, ySize);
    std::cout << "New ySize is: " << ySize << "\n\n";
    print2dArr(arr2d, ySize, xSize);
    std::cout << '\n';
    delete2dArr(arr2d, ySize);

    return 0;

    /*int ySize{ 10 };
    int xSize{ 8 };

    int** arr2d { new int* [ySize] };

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

    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            arr2d[y][x] = rand() % 10;
        }
    }

    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            std::cout << arr2d[y][x] << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    delete[] arr2d[ySize - 1];
    int** tmp = new int * [--ySize];
    for (int y{ 0 }; y < ySize; ++y)
    {
        tmp[y] = arr2d[y];
    }
    delete[] arr2d;
    arr2d = tmp;

    std::cout << "New ySize is: " << ySize << "\n\n";

    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            std::cout << arr2d[y][x] << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';

    for (int y{ 0 }; y < ySize; ++y)
    {
        delete[] arr2d[y];
    }
    delete[] arr2d;*/


    /*for (int y{ 0 }; y < ySize; ++y)
    {
        arr2dDyn[y] = new int[xSize];
    }*/

    //int arr2d[ySize][xSize]{ {12,23,34},{64,57,86} };

    //printArr((int*)arr2d, ySize * xSize);

    //return 0;

    //std::cout << (arr2dDyn[0] == nullptr) << '\n';
    //std::cout << (arr2dDyn[1] == nullptr) << '\n';
    //arr2dDyn[0] = new int[xSize] {1,2,3};
    //arr2dDyn[1] = new int[xSize] {4,5,6};

    //int* bigArr{ new int[ySize * xSize]{1,2,3,4,5,6} };

    //for (int y{ 0 }; y < ySize; ++y)
    //{
    //  for (int x{ 0 }; x < xSize; ++x)
    //  {
    //      arr2[y][x] = rand() % 10;
    //  }
    //  std::cout << '\n';
    //}

    //for (int y{ 0 }; y < ySize; ++y)
    //{
    //  for (int x{ 0 }; x < xSize; ++x)
    //  {
    //      std::cout << "Enter arr[" << y << "][" << x << "]\n";
    //      std::cin >> lineTo2dArr(bigArr, y, x, xSize);
    //  }
    //  std::cout << '\n';
    //}

    //for (int y{ 0 }; y < ySize; ++y)
    //{
    //  for (int x{ 0 }; x < xSize; ++x)
    //  {
    //      std::cout << lineTo2dArr(bigArr, y, x, xSize) << '\t';
    //  }
    //  std::cout << '\n';
    //}
    //for (int y{ 0 }; y < ySize; ++y)

    //{
    //  arr2dDyn[y] = bigArr + y * xSize;
    //}
    //printArr2dDyn(arr2dDyn, ySize, xSize);
    //delete[] arr2dDyn[0];
    //delete[] arr2dDyn[1];

    //delete[] bigArr;
    //for (int y{ 0 }; y < ySize; ++y)
    //{
    //  delete[] arr2dDyn[y];
    //}

    //delete[] arr2dDyn;

    ////int arr[xSize]{};
    //int* arrPtr{ new int[xSize] {1,2,3} };
    //
    //arrPtr[0] = 1;
    //arrPtr[1] = 2;
    //arrPtr[2] = 3;

    //*(arrPtr + 0) = 1;
    //*(arrPtr + 1) = 2;
    //*(arrPtr + 1) = 3;

    //delete[] arrPtr;
    //printArr2d(arr2d, ySize, xSize);

}