几种C++多维数组管理方法的性能测试

为了测试几种常用的原生多维数组管理方法，我们利用GNU C++ 7.2 最新的MSYS2版本，进行一个测试:
主要测试涵盖指针型的二维数组、vector\array\map

#include <vector>
#include <array>
#include <functional>
#include <map>
#include <unordered_map>
#include <stdio.h>
#include <time.h>
#include <malloc.h>
#include <memory>
#include <typeinfo>
//GNU C++ 7.2
//链接选项: -Wl,--stack,20240000
using namespace std;
const int testloopTimes = 1000;
const int d1 = 80;
const int d2 = 60;
const int d3 = 40;
const int d4 = 20;
//用于进行循环赋值测试的函数
template <typename T>
double function_loop(T p, int Ntimes)
{
    double  duration = 0;
    clock_t start, finish;
    start=clock();
    for (int c=0;c<Ntimes;++c)
        for(int h=0; h<d1; h++)
            for(int i=0; i<d2; i++)
                for(int j=0; j<d3; j++)
                    for(int k=0; k<d4; k++)
                        p[h][i][j][k]=h*60+i*20+j*5+k + c;
    finish=clock();
    duration=(double)(finish-start)/CLOCKS_PER_SEC;
    if (Ntimes>1)
        printf("\tloop cost: %f (s)\n",duration);
    return duration;
}
//用于测试含有构造、析构的函数
void test(function<double (void)> ftest)
{
    double  duration = 0;
    clock_t start, finish;
    start=clock();
    double loopCost = ftest();
    finish=clock();
    duration=(double)(finish-start)/CLOCKS_PER_SEC;
    printf("\tMEM  cost: %f (s)\n",duration - loopCost );
}
//vector 测试
double function_vector()
{
    vector<vector<vector<vector<int> > > >
            p(d1,vector<vector<vector<int> > >
              (d2,vector<vector<int> >
               (d3,vector<int>(d4,0))));
    printf ("test vector:\n");
    double loopCost = function_loop(p,testloopTimes);
    return loopCost;
}
//array 测试
double function_array()
{
    array<array<array<array<int,d4 >,d3 >,d2 >,d1> p{0};
    printf ("test array:\n");
    double loopCost = function_loop(p,testloopTimes);
    return loopCost;
}
//map 测试
double function_map()
{
    map<int,map<int,map<int,map<int,int > > >> p;
    printf ("test map:\n");
    function_loop(p,1);
    double loopCost = function_loop(p,testloopTimes);
    return loopCost;
}
//unordered_map 测试
double function_unordered_map()
{
    unordered_map<int,unordered_map<int,unordered_map
            <int,unordered_map<int,int > > >> p;
    printf ("test unordered_map:\n");
    function_loop(p,1);
    double loopCost = function_loop(p,testloopTimes);
    return loopCost;
}
//shared_ptr 测试
#if __GNUC__>= 7
double function_shared_ptr()
{
    shared_ptr<int[][d2][d3][d4]> p (new int [d1][d2][d3][d4]);
    printf ("test shared_ptr:\n");
    double loopCost = function_loop(p,testloopTimes);
    return loopCost;
}
#endif

//pointer测试
double function_pointer()
{
    printf ("test pointer:\n");
    int ****p = nullptr;
    int h,i,j;
    p=new int ***[d1];
    if (nullptr==p) return 0;
    for (h=0; h<d1; h++)
    {
        p[h]=new int ** [d2];
        if (nullptr==p[h]) return 0;
        for (i=0; i<d2; i++)
        {
            p[h][i]=new int *[d3];
            if (nullptr==p[h][i]) return 0;
            for (j=0; j<d3; j++)
            {
                p[h][i][j]=new int [d4];
                if (nullptr==p[h][i][j]) return 0;
            }
        }
    }
    double loopCost = function_loop(p,testloopTimes);
    for (h=0; h<d1; h++)
    {
        for (i=0; i<d2; i++)
        {
            for (j=0; j<d3; j++)
            {
                delete [] p[h][i][j];
            }
            delete [] p[h][i];
        }
        delete [] p[h];
    }
    delete [] p;
    return loopCost;
}

int main()
{
    test(function_vector);
    test(function_array);
    test(function_pointer);
    test(function_map);
    test(function_unordered_map);
#if __GNUC__>= 7
    test(function_shared_ptr);
#endif
    return 0;
}

输出结果如下：

test vector:
        loop cost: 1.594000 (s)
        MEM  cost: 0.046000 (s)
test array:
        loop cost: 1.204000 (s)
        MEM  cost: 0.000000 (s)
test pointer:
        loop cost: 1.500000 (s)
        MEM  cost: 0.015000 (s)
test map:
        loop cost: 156.454000 (s)
        MEM  cost: 0.563000 (s)
test unordered_map:
        loop cost: 83.639000 (s)
        MEM  cost: 0.609000 (s)
test shared_ptr:
        loop cost: 1.219000 (s)
        MEM  cost: 0.015000 (s)

可见，使用 shared_ptr 还是很划算的！用array、vector也不赖！