动态二维数组

/*

 cgl_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