arr2dDynLinear

// https://pastebin.com/edit/xNwQPu8P - separate new for each row version
#include <iostream>

int index2D(int y, int x, int xSize)
{
    return x + y * xSize;
}

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

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

template <typename T>
void fillArr(T** container, int ySize, int xSize)
{
    int cnt{ 1 };
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            container[y][x] = cnt++;
        }
    }
}

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

template <typename T>
T** createArr2DLinear(int ySize, int xSize)
{
    T** container{ new T * [ySize] };
    T* bigArr{ new T[ySize * xSize] };
    sliceBigArr(container, bigArr, ySize, xSize);
    return container;
}

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

template <typename T>
void deleteColumnArr2DLinear(T** container, int ySize, int& xSize, int columnPos)
{
    --xSize;
    T* newBigArr{ new T[ySize * xSize] };
    T* oldBigArr{ *container };
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            //newBigArr[x + xSize*y] = container[y][x + (x >= columnPos)];
            *(newBigArr + index2D(y,x,xSize)) = *(oldBigArr + index2D(y, x + (x >= columnPos), xSize));
        }

    }
    delete[] oldBigArr;
    sliceBigArr(container, newBigArr, ySize, xSize);
}

template <typename T>
void addColumnArr2DLinear(T** container, int ySize, int& xSize, int columnPos, T* newCol = nullptr)
{
    T* newBigArr{ new T[ySize * (xSize + 1)] };
    T* oldBigArr{ *container };
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            //newBigArr[x + (xSize + 1) * y + (x >= columnPos)] = container[y][x];
            *(newBigArr + index2D(y, x + (x >= columnPos), xSize + 1)) = *(oldBigArr + index2D(y,x,xSize));
        }

        //newBigArr[y * (xSize + 1) + columnPos] = newCol ? newCol[y] : 0;
        *(newBigArr + y * (xSize + 1) + columnPos) = newCol ? *(newCol + y) : 0;

    }
    delete[] oldBigArr;
    ++xSize;
    sliceBigArr(container, newBigArr, ySize, xSize);
}

template <typename T>
void deleteRowArr2DLinear(T**& container, int& ySize, int xSize, int rowPos)
{
    --ySize;
    T* newBigArr{ new T[ySize*xSize] };
    T* oldBigArr{ *container };
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            //newBigArr[x + (xSize)*y] = container[y + (y >= rowPos)][x];
            *(newBigArr + index2D(y,x,xSize)) = *(oldBigArr + index2D(y + (y >= rowPos),x,xSize));
        }

    }
    deleteArr2DLinear(container);
    container = new T * [ySize];
    sliceBigArr(container, newBigArr, ySize, xSize);
}

template <typename T>
void addRowArr2DLinear(T**& container, int& ySize, int xSize, int rowPos, T* newRow = nullptr)
{
    T* newBigArr{ new T[(ySize + 1) * xSize]};
    T* oldBigArr{ *container };
    for (int y{ 0 }; y < ySize; ++y)
    {
        for (int x{ 0 }; x < xSize; ++x)
        {
            //newBigArr[x + (xSize) * (y + (y >= rowPos))] = container[y][x];
            *(newBigArr + index2D(y + (y >= rowPos),x,xSize)) = *(oldBigArr + index2D(y,x,xSize));
        }
    }
    for (int x{ 0 }; x < xSize; ++x)
    {
        //newBigArr[x + (xSize)*rowPos] = newRow ? newRow[x] : 0;
        *(newBigArr + x + xSize * rowPos) = newRow ? *(newRow + x) : 0;
    }
    deleteArr2DLinear(container);
    ++ySize;
    container = new T * [ySize];
    sliceBigArr(container, newBigArr, ySize, xSize);
}

int main()
{
    int ySize{ 3 };
    int xSize{ 3 };
    auto arr2D{ createArr2DLinear<int>(ySize,xSize) };

    fillArr(arr2D, xSize, ySize);
    printArr(arr2D, ySize, xSize);

    deleteColumnArr2DLinear(arr2D, ySize, xSize, 2);
    printArr(arr2D, ySize, xSize);

    auto newCol{ new int[ySize] {1,2,3} };
    addColumnArr2DLinear(arr2D, ySize, xSize, 0, newCol);
    printArr(arr2D, ySize, xSize);

    deleteRowArr2DLinear(arr2D, ySize, xSize, 2);
    printArr(arr2D, ySize, xSize);

    auto newRow{ new int[xSize] {1,2,3} };
    addRowArr2DLinear(arr2D, ySize, xSize, 2, newRow);
    printArr(arr2D, ySize, xSize);

    deleteArr2DLinear(arr2D);

    delete[] newCol;
    delete[] newRow;
    return 0;
}