C++ Существует ли быстрый многомерный массив, который позволяет использовать подмассивы разного размера?

Недавно я перешел с Java на C++ и заметил падение производительности при использовании массивов стандартной библиотеки. Я написал одну и ту же программу на Java и C++ (или, по крайней мере, настолько похожую, насколько я мог себе представить), чтобы записывать время их выполнения.

Java-код:

    public static void main(String args[]) {
        long stime = System.currentTimeMillis();
        
        double[][] arr = new double[4][];
        arr[0] = new double[5];
        arr[1] = new double[10];
        arr[2] = new double[5];
        arr[3] = new double[8];
        
        for(int l = 0; l < arr.length; l++) {
            for(int i  = 0; i < arr[l].length; i++) {
                arr[l][i] = 1;
            }
        }
        
        for(int t = 0; t < 100000000; t++) {
            for(int l = 0; l < arr.length; l++) {
                for(int i  = 0; i < arr[l].length; i++) {
                    arr[l][i] += t;
                    arr[l][i] *= t;
                    arr[l][i] /= t;
                }
            }
        }
        
        System.out.println("time: " + ((System.currentTimeMillis() - stime) / 1000.0f));
    }

Код С++:

int main()
{
    int subarray_sizes[] = {5,10,5,8};

    double** arr = new double*[4];
    arr[0] = new double[subarray_sizes[0]];
    arr[1] = new double[subarray_sizes[1]];
    arr[2] = new double[subarray_sizes[2]];
    arr[3] = new double[subarray_sizes[3]];

    for(int l = 0; l < 4; l++){
        for(int i = 0; i < subarray_sizes[l]; i++){
            arr[l][i] = 1;

        }
    }

    for(int t = 0; t < 100000000; t++){
        for(int l = 0; l < 4; l++){
            for(int i = 0; i < subarray_sizes[l]; i++){
                arr[l][i] += t;
                arr[l][i] *= t;
                arr[l][i] /= t;
            }
        }
    }

    delete[] arr[3];
    delete[] arr[2];
    delete[] arr[1];
    delete[] arr[0];
    delete[] arr;
}

Один запуск программы на Java занял 3,125 секунды, а программы на C++ — 25,372 секунды. Я понимаю, что это не лучший способ измерения производительности, однако я сомневаюсь, что это расхождение во времени выполнения вызвано просто случайностью.

Я также видел векторы, используемые вместо массивов во многих программах на C++, поэтому я написал программу с векторами. Код С++:

int main()
{
    int subarray_sizes[] = {5,10,5,8};

    std::vector<std::vector<double>> arr(4);
    arr[0].resize(5);
    arr[1].resize(10);
    arr[2].resize(5);
    arr[3].resize(8);

    for(int l = 0; l < arr.size(); l++){
        for(int i = 0; i < arr[l].size(); i++){
            arr[l][i] = 1;

        }
    }

    for(int t = 0; t < 100000000; t++){
        for(int l = 0; l < arr.size(); l++){
            for(int i = 0; i < arr[l].size(); i++){
                arr[l][i] += t;
                arr[l][i] *= t;
                arr[l][i] /= t;
            }
        }
    }
}

Однако это дало худшие результаты - 46,806 секунды.

Короче говоря, мне интересно, есть ли в C++ структура данных, которая позволяет мне иметь подмассивы переменной длины, время выполнения которых сопоставимо со временем выполнения массивов в Java.