二维数组分配释放

template<int N>
void my_malloc(int row)
{
	// N 必须编译期间确定
	int (*arrPtr)[N] = new int[row][N];
	
	arrPtr[0][0] = 0;
	arrPtr[0][1] = 0;

	delete []arrPtr;
}

N必须编译期间确定，这种方式连续存储。调用直观。

int** my_malloc(int row, int col)
{
	return (int**)new int[row*col];
}
void my_free(int** pptr, int row)
{
	delete[] (int*)pptr;
}

强制转化为int**,连续存储，支持直观调用ptr[0][1] = 1;

类似的一种常规方案是：for循环分配，行优先。

class myMalloc
{
	int _row;
	int _col;
	int* _ptr;
public:
	myMalloc(int row, int col)
		: _row(row)
		, _col(col)
		, _ptr(0)
	{
		_ptr = new int[row*col];
	}
	~myMalloc()
	{
		if (_ptr)
			delete[] _ptr;
	}
	
	// 隐式转化支持 myMalloc[0][1]行为
	operator int** ()
	{
		return (int**)_ptr;
	}

	// myMalloc(0, 0)
	int& operator()(int i, int j)
	{
		return _ptr[i*_row + j];
	}

	// 返回指针支持 myMalloc[0][1]行为
	int* operator[](int i)
	{
		return _ptr + i*_row;
	}
};

C++的方式封装，重载运算符，连续存储，支持直观调用。