arr2dDynSBD192Practice1

#include <iostream>

template <typename T>
void printArr2d(T 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] << ' ';
        }
        std::cout << '\n';
    }
}

template <typename T>
void printArr2dDyn(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] << '\t';
        }
        std::cout << '\n';
    }
}

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

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

template <typename T>
void printArr2d(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] << '\t';
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}

template <typename T>
void fillArr2d(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 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);
}


template <typename T>
void addColArr2d(T** arr2d, int ySize, int& xSize, int colPos, T* newCol = nullptr)
{
    T* newRow;
    for (int y{ 0 }; y < ySize; ++y)
    {
        newRow = new T[xSize + 1]{};
        /*      colPos = 2;
              1 2 3 4 5
              1 2 0 3 4 5*/
        for (int x{ 0 }; x < xSize; ++x)
        {
            newRow[x + (x < colPos ? 0 : 1)] = arr2d[y][x];
        }
        if (newCol) { newRow[colPos] = newCol[y]; };
        delete[] arr2d[y];
        arr2d[y] = newRow;
    }
    ++xSize;
}

template <typename T>
void sliceArr2d(T** arr2d, int ySize, int xSize, T* bigArr)
{
    for (int y{ 0 }; y < ySize; ++y)
    {
        arr2d[y] = bigArr + y * xSize;
    }
}

template <typename T>
T** createArr2dLinear(int ySize, int xSize)
{
    T** arr2d{ new T * [ySize] };
    T* bigArr{ new T[ySize * xSize] {} };
    sliceArr2d(arr2d, ySize, xSize, bigArr);
    return arr2d;
}

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

template <typename T>
void addColArr2dLinear(T** arr2d, int ySize, int& xSize, int colPos, T* newCol = nullptr)
{
    T* newBigArr{ new int[ySize * (xSize + 1)]{} };

    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            newBigArr[y * (xSize + 1) + x + (x < colPos ? 0 : 1)] = arr2d[y][x];
        }
        if (newCol)
        {
            newBigArr[y * (xSize + 1) + colPos] = newCol[y];
        }
    }

    xSize++;
    delete[] arr2d[0];
    sliceArr2d(arr2d, ySize, xSize, newBigArr);
}

int main()
{
    int ySize{ 3 };
    int xSize{ 5 };

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

    //for (int y{ 0 }; y < ySize; ++y)
    //{
    //    arr2d[y] = new int[xSize] {1,2,3,4,5};
    //}
    int** arr2d = createArr2dLinear<int>(ySize, xSize);

    printArr2d(arr2d, ySize, xSize);
    fillArr2d(arr2d, ySize, xSize);
    printArr2d(arr2d, ySize, xSize);
    int colPos{ 2 };
    int* newCol{ new int[ySize] { 11,12,13 } };
    addColArr2dLinear(arr2d, ySize, xSize, colPos);
    printArr2d(arr2d, ySize, xSize);

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