arr2dDynPracticeBBV192

#include <iostream>

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

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

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() % 20;
        }
    }
}

//template <typename T>
//void deleteLastLine2dArr(T**& arr2d, int& ySize)
//{
//  delete[] arr2d[ySize - 1];
//  T** tmp = new T* [--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)
        {
            //newRow[                       x + (x < colPos ? 0 : 1)] = arr2d[y][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 ySzie{ 3 };
    int xSize{ 3 };

    //int** arr2d{ createArr2d<int>(ySzie,xSize) };
    //printArr2d(arr2d, ySzie, xSize);

    //fillArr2d(arr2d, ySzie, xSize);
    //printArr2d(arr2d, ySzie, xSize);
    //
    //int* newCol{ new int[ySzie] {11,12,13} };
    //addColArr2d(arr2d, ySzie, xSize, 1, newCol);
    //printArr2d(arr2d, ySzie, xSize);

    //deleteLine2dArr(arr2d, ySzie, 1);
    //printArr2d(arr2d, ySzie, xSize);

    //deleteArr2d(arr2d, ySzie);
    //delete[] newCol;


    int** arr2d{ createArr2dLinear<int>(ySzie,xSize) };
    printArr2d(arr2d, ySzie, xSize);

    fillArr2d(arr2d, ySzie, xSize);
    printArr2d(arr2d, ySzie, xSize);

    int* newCol{ new int[ySzie] {11,12,13} };
    addColArr2dLinear(arr2d, ySzie, xSize, 1, newCol);
    printArr2d(arr2d, ySzie, xSize);

    deleteArr2dLinear(arr2d);
    delete[] newCol;
}