标签：const int array2d 二维 vector 数组 array 动态 size

/*
 array2d.hpp

 sdragon 2006-10-08 22:26:44

 创建二维数组的程序。array2d<T>::array_t 是 C 的纯指针模式，一定要使用
   delete_array2d<T>()删除。
 由 vector<T> 创建的数组的效率要高一些
*/
#ifndef CGL_ARRAY2D_HPP_20061008222644
#define CGL_ARRAY2D_HPP_20061008222644
 
#include <vector>
 
namespace cgl{
 
/*C风格的二维数组*/
template<typename T>
void new_array2d(T** &v, int size_x, int size_y)
{
    v = new T*[size_y];
    for(int y=0; y < size_y; ++y)
        v[y] = new T[size_x];
}
 
template<typename T>
void new_array2d(T** &v, int size_x, int size_y, const T& val)
{
    v = new T*[size_y];
    for(int y=0; y < size_y; ++y)
    {
        v[y] = new T[size_x];
        for(int x=0; x < size_x; ++x)
            v[y][x] = val;
    }
}
 
template<typename T>
void delete_array2d(T** &v, int size_y)
{
    for(int y=0; y < size_y; ++y)
        delete[] v[y];
    delete[] v;
    v = NULL;
}
 
/*vector<T>风格的动态数组*/
template<typename T>
void new_array2d(std::vector<std::vector<T> > &v, int size_x, int size_y)
{
    v.resize(size_y);
    for(int y=0; y < size_y; ++y){
        v[y].resize(size_x);
    }
 
    //下面是两种效率低下的初始化方法，这些都是c++的“坑”
    //方案2
    //速度差不多，当size_y增大的时候，这种方案速度会越来越慢
    //这个会产生一个vector<y>的临时变量，并对每一次x初始化进行复制
    //v.resize(size_x, std::vector<T>(size_y));
    //v.swap( std::vector<std::vector<T> >(size_x, std::vector<T>(size_y)) );
    //方案3
    //直接符值的速度非常慢，直接初始化的速度也是非常慢
    //这个会产生一个整个数组的副本，然后赋值给变量
    //v = std::vector<std::vector<T> >(size_x, std::vector<T>(size_y))
}
 
template<typename T>
void new_array2d(std::vector<std::vector<T> > &v, int size_x, int size_y, const T& val)
{
    v.resize(size_y);
    for(int y=0; y < size_y; ++y)
        v[y].resize(size_x, val);
}
 
template<typename T>
void delete_array2d(std::vector<std::vector<T> > &v)
{
    std::vector<std::vector<T> > tmp;
    v.swap(tmp);
}
 
/*
** vector<T>的二维数组
*/
 
template<typename T>
class array2d
{
public:
    typedef T value_type;
    typedef std::vector<T> array_x;
    typedef std::vector<array_x> array_y;
private:
    array_y m_array;
public:
    array2d():m_array(){/*void*/}
    array2d(const array2d& v):m_array(v){/*void*/}
    array2d(size_t x, size_t y)
    {
        this->resize(x, y);
    }
    array2d(size_t x, size_t y, const T& value)
    {
        this->resize(x, y, value);
    }
 
    bool empty()const
    {
        return m_array.empty();
    }
 
    void clear()
    {
        delete_array2d<T>(m_array);
    }
 
    array_x& operator[](int y)
    {
        return m_array[y];
    }
 
    const array_x& operator[](int y)const
    {
        return m_array[y];
    }
 
    array2d<T>& operator=(const array2d<T>& v)
    {
        m_array = v.m_array;
        return *this;
    }
 
    size_t size()const
    {
        return size_x() * size_y();
    }
 
    size_t size_x()const
    {
        return empty() ? 0 : m_array[0].size();
    }
 
    size_t size_y()const
    {
        return m_array.size();
    }
 
    void resize(size_t x, size_t y)
    {
        new_array2d<T>(m_array, x, y);
    }
 
    void resize(size_t x, size_t y, const value_type& value)
    {
        new_array2d<T>(m_array, x, y, value);
    }
 
    void swap(array2d<T>& v)
    {
        m_array.swap(v.m_array);
    }
};
 
}// end namespace cgl
 
#endif //CGL_ARRAY2D_HPP_20061008222644

文章发布于 2018-08-20 13:35:25 CSDN，现转博客园。

标签：const,int,array2d,二维,vector,数组,array,动态,size
来源： https://www.cnblogs.com/sdragonx/p/16287987.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。