一，利用模板來定制N維網格，這在開發一些與棋類有關的游戲等時幫助很大，因為是可擴展的，而且可以重用。以下摘抄其主要的代碼片斷。
#ifndef NDGRID_H
#define NDGRID_H

template <typename T, int N>
class NDGrid
{
public:
?NDGrid();
?NDGrid(int inSize);
?NDGrid(const NDGrid<T,N>& src);
?~NDGrid();

?NDGrid<T,N>& operator=(const NDGrid<T,N>& rhs);
?void resize(int newSize);
?NDGrid<T,N-1>& operator[](int x);
?const NDGrid<T,N-1>& operator[](int x) const;
?int getSize() const {return mSize; }
?static const int kDefaultSize = 10;
protected:
?void copyFrom(const NDGrid<T,N>& src);
?NDGrid<T,N-1>* mElems;
?int mSize;
};

template <typename T>
class NDGrid<T,1>
{
public:
?NDGrid(int inSize = kDefaultSize);
?NDGrid(const NDGrid<T,1>& src);
?~NDGrid();
?NDGrid<T,1>& operator=(const NDGrid<T,1>& rhs);
?void resize(int newSize);
?T& operator[](int x);
?const T& operator[](int x) const;
?int getSize() const { return mSize; }
?static const int kDefaultSize = 10;
protected:
?void copyFrom(const NDGrid<T,1>& src);
?T* mElems;
?int mSize;
};

#endif

#include "NDGrid.h"

template <typename T,int N>
const int NDGrid<T,N>::kDefaultSize;

template <typename T,int N>
NDGrid<T,N>::NDGrid(int inSize) : mSize(inSize)
{
?mElems = new NDGrid<T,N-1>[mSize];
?for(int i = 0; i < mSize; i++){
??mElems[i].resize(inSize);
?}
}

template <typename T, int N>
NDGrid<T,N>::NDGrid() : mSize(kDefaultSize)
{
?mElems = new NDGrid<T,N-1>[mSize];
}

template <typename T, int N>
NDGrid<T,N>::NDGrid(const NDGrid<T,N>& src)
{
?copyFrom(src);
}

template <typename T, int N>
NDGrid<T,N>::~NDGrid()
{
?delete [] mElems;
}

template <typename T,int N>
void NDGrid<T,N>::copyFrom(const NDGrid<T,N>& src)
{
?mSize = src.mSize;
?mElems = new NDGrid<T,N-1>[mSize];
?for(int i = 0; i < mSize; i++){
??mElems[i] = src.mElems[i];
?}
}

template <typename T,int N>
NDGrid<T,N>& NDGrid<T,N>::operator =(const NDGrid<T,N>& rhs)
{
?//check for self-assignment
?if(this == &rhs){
??return (*this);
?}
?//free the old memory
?delete [] mElems;
?//copy the new memory
?copyFrom(rhs);
?return (*this);
}

template <typename T,int N>
void NDGrid<T,N>::resize(int newSize)
{
?//////allocate the new array iwth the new size
?NDGrid<T,N-1>* newElems = new NDGrid<T,N-1>[newSize];
?//copy all the elements, handling the cases where new Size
?//is larger than mSize nd smaller than msize.
?for(int i = 0; i < newSize && i < mSize; i++){
??newElems[i] = mElems[i];
??//resize the nested Grid elems recursively.
??newElems[i].resize(newSize);
?}
?//store the new size and pointer to the new array.
?//free the memory for the old array first.
?mSize = newSize;
?delete [] mElems;
?mElems = newElems;
}

template <typename T,int N>
NDGrid<T,N-1>& NDGrid<T,N>::operator [](int x)
{
?return (mElems[x]);
}

template <typename T,int N>
const NDGrid<T,N-1>& NDGrid<T,N>::operator [](int x) const
{
?return (mElems[x]);
}

//////specialization? implementation

template <typename T>
const int NDGrid<T,1>::kDefaultSize;

template <typename T>
NDGrid<T,1>::NDGrid(int inSize) : mSize(inSize)
{
?mElems = new T[mSize];
}

template < typename T>
NDGrid<T,1>::NDGrid(const NDGrid<T,1>& src)
{
?copyFrom(src);
}

template <typename T>
NDGrid<T,1>::~NDGrid()
{
?delete [] mElems;
}

template <typename T>
void NDGrid<T,1>::copyFrom(const NDGrid<T,1>& src)
{
?mSize = src.mSize;
?mElems = new T[mSize];
?for(int i = 0; i < mSize; i++){
??mElems[i] = src.mElems[i];
?}
}

template < typename T>
NDGrid<T,1> & NDGrid<T,1>::operator =(const NDGrid<T,1>& rhs)
{
?//check for self-assignment
?if(this == & rhs){
??return(*this);
?}
?delete [] mElems;
?copyFrom(rhs);
?return (*this);
}

template <typename T>
void NDGrid<T,1>::resize(int newSize)
{
?T* newElems = new T[newSize];

?for(int i =0; i < newSize && i < mSize; i++){
??newElems[i] = mElems[i];
??///don't need to resize recursively,because this is the base case.
?}
?mSize = newSize;
?delete [] mElems;
?mElems = newElems;
}

template <typename T>
T& NDGrid<T,1>::operator [](int x)
{
?return (mElems[x]);
}

template <typename T>
const T& NDGrid<T,1>::operator [](int x) const
{
?return (mElems[x]);
}

#include <iostream>
using namespace std;
#include "NDGrid.h"

int main()
{
?NDGrid<int,3> my3DGrid;
?my3DGrid[2][1][2] = 5;
?my3DGrid[1][1][1] = 5;

?NDGrid<float,2> my2DGrid;
?my2DGrid[5][2] = 3;
?my2DGrid[2][5] = 2;

?cout << my3DGrid[2][1][2] << endl;

?cout<<my2DGrid[5][2]<<endl;

?return 0;
}