C++ 使用C++；

我编写了一个简单的小程序，比较了用不同类型的容器填充简单8x8矩阵的几种方法的性能。以下是代码：

#define MATRIX_DIM 8
#define OCCUR_MAX 100000

static void genHeapAllocatedMatrix(void)
{
    int **pPixels = new Pixel *[MATRIX_DIM];

    for (type::uint32 idy = 0; idy < MATRIX_DIM; idy++) {
        pPixels[idy] = new Pixel[MATRIX_DIM];
        for (type::uint32 idx = 0; idx < MATRIX_DIM; idx++)
            pPixels[idy][idx] = 42;
    }
}

static void genStackAllocatedMatrix(void)
{
    std::array<std::array<int, 8>, 8> matrix;

    for (type::uint32 idy = 0; idy < MATRIX_DIM; idy++) {
        for (type::uint32 idx = 0; idx < MATRIX_DIM; idx++) {
            matrix[idy][idx] = 42;
        }
    }
}

static void genStackAllocatedMatrixBasic(void)
{
    int matrix[MATRIX_DIM][MATRIX_DIM];

    for (type::uint32 idy = 0; idy < MATRIX_DIM; idy++) {
        for (type::uint32 idx = 0; idx < MATRIX_DIM; idx++) {
            matrix[idy][idx] = 42;
        }
    }
}

int main(void)
{
    clock_t begin, end;
    double time_spent;

    begin = clock();

    for (type::uint32 idx = 0; idx < OCCUR_MAX; idx++)
    {
        //genHeapAllocatedMatrix();
        genStackAllocatedMatrix();
        //genStackAllocatedMatrixBasic();
    }

    end = clock();

    time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
    std::cout << "Elapsed time = " << time_spent << std::endl;

    return (0);
}

#定义矩阵图8
#定义最大值为100000
静态空隙GenheapLocatedMatrix（空隙）
{
int**pPixels=新像素*[MATRIX_DIM]；
对于（类型：uint32 idy=0；idy这是因为二维数组不是指针数组

因此，对于
矩阵
类型，您应该使用
int*
，但是您当然不能按二维对其进行索引

另一个选项是存储指向数组的指针：

int (*matrix)[MATRIX_DIM][MATRIX_DIM];

matrix = &tab;
std::cout << (*matrix)[0][0] << std::endl;

int（*矩阵）[matrix_DIM][matrix_DIM]；
矩阵=&tab；
这是因为二维数组不是指针数组

因此，对于
矩阵
类型，您应该使用
int*
，但是您当然不能按二维对其进行索引

另一个选项是存储指向数组的指针：

int (*matrix)[MATRIX_DIM][MATRIX_DIM];

matrix = &tab;
std::cout << (*matrix)[0][0] << std::endl;

int（*矩阵）[matrix_DIM][matrix_DIM]；
矩阵=&tab；
这是因为二维数组不是指针数组

因此，对于
矩阵
类型，您应该使用
int*
，但是您当然不能按二维对其进行索引

另一个选项是存储指向数组的指针：

int (*matrix)[MATRIX_DIM][MATRIX_DIM];

matrix = &tab;
std::cout << (*matrix)[0][0] << std::endl;

int（*矩阵）[matrix_DIM][matrix_DIM]；
矩阵=&tab；
这是因为二维数组不是指针数组

因此，对于
矩阵
类型，您应该使用
int*
，但是您当然不能按二维对其进行索引

另一个选项是存储指向数组的指针：

int (*matrix)[MATRIX_DIM][MATRIX_DIM];

matrix = &tab;
std::cout << (*matrix)[0][0] << std::endl;

int（*矩阵）[matrix_DIM][matrix_DIM]；
矩阵=&tab；
std:：cout使用单个数组来表示矩阵，而不是为每个索引分配

我已经为此编写了一个类。请随意使用它：

#include <vector>

template<typename T, typename Allocator = std::allocator<T>>
class DimArray
{
    private:
        int Width, Height;
        std::vector<T, Allocator> Data;

    public:
        DimArray(int Width, int Height);
        DimArray(T* Data, int Width, int Height);
        DimArray(T** Data, int Width, int Height);
        virtual ~DimArray() {}

        DimArray(const DimArray &da);
        DimArray(DimArray &&da);

        inline std::size_t size() {return Data.size();}
        inline std::size_t size() const {return Data.size();}

        inline int width() {return Width;}
        inline int width() const {return Width;}

        inline int height() {return Height;}
        inline int height() const {return Height;}

        inline T* operator [](const int Index) {return Data.data() + Height * Index;}
        inline const T* operator [](const int Index) const {return Data.data() + Height * Index;}

        inline DimArray& operator = (DimArray da);
};

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(int Width, int Height) : Width(Width), Height(Height), Data(Width * Height, 0) {}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(T* Data, int Width, int Height) : Width(Width), Height(Height), Data(Width * Height, 0) {std::copy(&Data[0], &Data[0] + Width * Height, const_cast<T*>(this->Data.data()));}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(T** Data, int Width, int Height) : Width(Width), Height(Height), Data(Width * Height, 0) {std::copy(Data[0], Data[0] + Width * Height, const_cast<T*>(this->Data.data()));}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(const DimArray &da) : Width(da.Width), Height(da.Height), Data(da.Data) {}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(DimArray &&da) : Width(std::move(da.Width)), Height(std::move(da.Height)), Data(std::move(da.Data)) {}

template<typename T, typename Allocator>
DimArray<T, Allocator>& DimArray<T, Allocator>::operator = (DimArray<T, Allocator> da)
{
    this->Width = da.Width;
    this->Height = da.Height;
    this->Data.swap(da.Data);
    return *this;
}

#包括
模板
类DimArray
{
私人：
int宽度、高度；
std：：矢量数据；
公众：
DimArray（整数宽度、整数高度）；
DimArray（T*数据、整数宽度、整数高度）；
DimArray（T**数据、整数宽度、整数高度）；
虚拟~DimArray（）{}
DimArray（常量DimArray和da）；
DimArray（DimArray&&da）；
内联std:：size_t size（）{return Data.size（）；}
内联std:：size_t size（）const{return Data.size（）；}
内联int-width（）{return width；}
内联int width（）常量{return width；}
内联int height（）{return height；}
内联int height（）常量{return height；}
内联T*运算符[]（const int Index）{return Data.Data（）+Height*Index；}
内联常量T*运算符[]（常量int索引）常量{return Data.Data（）+Height*Index；}
内联DimArray&运算符=（DimArray da）；
};
模板
DimArray:：DimArray（整型宽度，整型高度）：宽度（宽度），高度（高度），数据（宽度*高度，0）{}
模板
DimArray:：DimArray（T*Data，int-Width，int-Height）：宽度（Width），高度（Height），数据（Width*Height，0）{std:：copy（&Data[0]，&Data[0]+宽度*Height，const_cast（this->Data.Data（））；}
模板
DimArray:：DimArray（T**Data，int-Width，int-Height）：宽度（Width），高度（Height），数据（Width*Height，0）{std:：copy（Data[0]，Data[0]+宽度*Height，const_cast（this->Data.Data（））；}
模板
DimArray:：DimArray（常量DimArray&da）：宽度（da.Width）、高度（da.Height）、数据（da.Data）{
模板
DimArray:：DimArray（DimArray&&da）：宽度（std:：move（da.Width）），高度（std:：move（da.Height）），数据（std:：move（da.Data））{}
模板
DimArray&DimArray:：运算符=（DimArray da）
{
此->宽度=数据宽度；
此->高度=数据高度；
此->数据交换（da.Data）；
归还*这个；
}

用法：

int main()
{
    DimArray<int> Matrix(1000, 1000); //creates a 1000 * 1000 matrix.
    Matrix[0][0] = 100;  //ability to index it like a multi-dimensional array.
}

template<typename T, std::size_t size>
class uninitialised_stack_allocator : public std::allocator<T>
{
    private:
        alignas(16) T data[size];

    public:
        typedef typename std::allocator<T>::pointer pointer;
        typedef typename std::allocator<T>::size_type size_type;
        typedef typename std::allocator<T>::value_type value_type;

        template<typename U>
        struct rebind {typedef uninitialised_stack_allocator<U, size> other;};

        pointer allocate(size_type n, const void* hint = 0) {return static_cast<pointer>(&data[0]);}
        void deallocate(void* ptr, size_type n) {}
        size_type max_size() const {return size;}
};

int main()
{
    DimArray<int, uninitialised_stack_allocator<int, 1000 * 1000>> Matrix(1000, 1000);
}

intmain（）
{
DimArray矩阵（10001000）；//创建一个1000*1000矩阵。
矩阵[0][0]=100；//能够像多维数组一样对其进行索引。
}

更多用法：

int main()
{
    DimArray<int> Matrix(1000, 1000); //creates a 1000 * 1000 matrix.
    Matrix[0][0] = 100;  //ability to index it like a multi-dimensional array.
}

template<typename T, std::size_t size>
class uninitialised_stack_allocator : public std::allocator<T>
{
    private:
        alignas(16) T data[size];

    public:
        typedef typename std::allocator<T>::pointer pointer;
        typedef typename std::allocator<T>::size_type size_type;
        typedef typename std::allocator<T>::value_type value_type;

        template<typename U>
        struct rebind {typedef uninitialised_stack_allocator<U, size> other;};

        pointer allocate(size_type n, const void* hint = 0) {return static_cast<pointer>(&data[0]);}
        void deallocate(void* ptr, size_type n) {}
        size_type max_size() const {return size;}
};

int main()
{
    DimArray<int, uninitialised_stack_allocator<int, 1000 * 1000>> Matrix(1000, 1000);
}

模板
类未初始化的\u堆栈\u分配器：public std:：allocator
{
私人：
alignas（16）T数据[大小]；
公众：
typedef typename std:：分配器:：指针指针；
typedef typename std:：分配器：：大小\类型大小\类型；
typedef typename std:：分配器：：值\类型值\类型；
模板
结构重新绑定{typedef uninitialized_stack_allocator other；}；
指针分配（size_type n，const void*hint=0）{return static_cast（&data[0]）；}
void释放（void*ptr，大小\类型n）{}
size_type max_size（）常量{return size；}
};
int main（）
{
DIM阵列矩阵（10001000）；
}
使用单个数组表示矩阵，而不是为每个索引分配

我已经为此编写了一个类。请随意使用它：

#include <vector>

template<typename T, typename Allocator = std::allocator<T>>
class DimArray
{
    private:
        int Width, Height;
        std::vector<T, Allocator> Data;

    public:
        DimArray(int Width, int Height);
        DimArray(T* Data, int Width, int Height);
        DimArray(T** Data, int Width, int Height);
        virtual ~DimArray() {}

        DimArray(const DimArray &da);
        DimArray(DimArray &&da);

        inline std::size_t size() {return Data.size();}
        inline std::size_t size() const {return Data.size();}

        inline int width() {return Width;}
        inline int width() const {return Width;}

        inline int height() {return Height;}
        inline int height() const {return Height;}

        inline T* operator [](const int Index) {return Data.data() + Height * Index;}
        inline const T* operator [](const int Index) const {return Data.data() + Height * Index;}

        inline DimArray& operator = (DimArray da);
};

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(int Width, int Height) : Width(Width), Height(Height), Data(Width * Height, 0) {}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(T* Data, int Width, int Height) : Width(Width), Height(Height), Data(Width * Height, 0) {std::copy(&Data[0], &Data[0] + Width * Height, const_cast<T*>(this->Data.data()));}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(T** Data, int Width, int Height) : Width(Width), Height(Height), Data(Width * Height, 0) {std::copy(Data[0], Data[0] + Width * Height, const_cast<T*>(this->Data.data()));}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(const DimArray &da) : Width(da.Width), Height(da.Height), Data(da.Data) {}

template<typename T, typename Allocator>
DimArray<T, Allocator>::DimArray(DimArray &&da) : Width(std::move(da.Width)), Height(std::move(da.Height)), Data(std::move(da.Data)) {}

template<typename T, typename Allocator>
DimArray<T, Allocator>& DimArray<T, Allocator>::operator = (DimArray<T, Allocator> da)
{
    this->Width = da.Width;
    this->Height = da.Height;
    this->Data.swap(da.Data);
    return *this;
}

#包括
模板
类DimArray
{
私人：
int宽度、高度；
标准：：vec