C++技巧之二维动态数组类模板

C++技巧之二维动态数组类模板2011-05-31C++提供了许多强大的机制来实现代码的高度复用、来使我们使用我们自已的类就像使用内置类型那样方便快捷。比如模板，运算符重载等等。模板好比如是一个大批量生产函数和类的工厂，使我们不用再去关心与数据类型相关的繁琐编程细节，把我们精力留给那些真正值得我们去认真思考的地方。而运算符重载则使我们的程序更直观更简洁，这不仅使我们更容易读懂我们的程序，而且使我们能以一种更为流畅的方式来表达我们的想法。就像上篇文章说到的，如果我们把动态分配的二维数组用类模板实现，并重载相应的操作符，我们就能十分方便的使用我们自己定义的数组类型了。今天我正好把以往的程序整理了一下，就一并贴了出来，看下面的程序。下面的两个类模板在vc++6.0上编译运行良好，测试程序也都得到正确的结果，如果在其他编译环境下有什么问题，欢迎给我留言。

第一个头文件Array.h是一维动态数组类模板：

//Array.h
#ifndef CARL_SEN_ARRAY_H
#define CARL_SEN_ARRAY_H

#include <iostream>
#include <cstdarg>
using std::out_of_range;
using std::ostream;

template<typename T>
class Array {
protected:
unsigned int size;
T* data;
public:
//构造函数
Array（unsigned int _size=0）;
Array（unsigned int count, T data1, ...）;

//复制控制
Array（const Array<T>& array）;
Array& operator=（const Array<T>& array）;
~Array（） {
delete[] data;
}
//两种重载运算符
T& operator[]（unsigned int index）;
const T& operator[]（unsigned int index） const;
friend ostream& operator<<（ostream& os, const Array<T>& array）;

//get，set成员函数
unsigned int getSize（） const {
return size;
}
void setSize（unsigned int newSize）;
};

template <typename T>
Array<T>::Array（unsigned int _size）:data（new T[_size]）, size（_size） {
for（unsigned int i=0; i<size; ++i） {
data[i]=T（）;
}
}

template <typename T>
Array<T>::Array（unsigned int count, T data1, ...）:size（count）, data（new T[count]） {
va_list ap;
va_start（ap, count）;
for（unsigned int i=0; i<size; ++i） {
data[i]=va_arg（ap, T）;
}
va_end（ap）;
}

template <typename T>
Array<T>::Array（const Array<T>& array）:size（array.size）, data（new T[array.size]） {
for（unsigned int i=0; i<size; ++i） {
data[i]=array.data[i];
}
}

template <typename T>
Array<T>& Array<T>::operator=（const Array<T>& array） {
if（&array！=this） {
delete[] data;
data=new T[array.size];
size=array.size;
for（unsigned int i=0; i<size; ++i） {
data[i]=array.data[i];
}
}
return *this;
}

template <typename T>
T& Array<T>::operator[]（unsigned int index） {
if（index>=size） {
throw out_of_range（"invalid index"）;
}
return data[index];
}

template <typename T>
const T& Array<T>::operator[]（unsigned int index） const {
if（index>=size） {
throw out_of_range（"invalid index"）;
}
return data[index];
}

template <typename T>
void Array<T>::setSize（unsigned int newSize） {
T* const newData=new T[newSize];
const unsigned int Min=size<newSize？size:newSize;
for（unsigned int i=0; i<Min; ++i） {
newData[i]=data[i];
}
delete[] data;
data=newData;
size=newSize;
}

template <typename T>
ostream& operator<<（ostream& os, const Array<T>& array） {
for（int i=0; i<array.size; ++i） {
os<<array.data[i]<<"	";
}
return os;
}

#endif

第二个头文件Array2D.h是二维动态数组类模板：
//Array2D.h
#ifndef CARL_SEN_ARRAY2D_H
#define CARL_SEN_ARRAY2D_H

#include "Array.h"
#include <iostream>
#include <cstdarg>
using std::ostream;
using std::out_of_range;

template <typename T>
class Array2D {
protected:
unsigned int rows;
unsigned int cols;
Array<T> array;
public:
//构造函数
Array2D（unsigned int _rows=0, unsigned int _cols=0）;
Array2D（unsigned int _rows, unsigned int _cols, T data1, ...）;
//两种重载运算符
class RowArray;
RowArray operator[]（unsigned int row）;
const RowArray operator[]（unsigned int row） const;
friend ostream& operator<<（ostream& os, const Array2D<T>& array2D）;

//计算第二维下标操作的嵌套类
class RowArray {
private:
const Array2D<T>& array2D;
unsigned int row;
public:
RowArray（Array2D<T>& _array2D, unsigned int _row=0）:
array2D（_array2D）, row（_row） {}
RowArray（const Array2D<T>& _array2D, unsigned int _row=0）:
array2D（_array2D）, row（_row） {}
T& operator[]（unsigned int col） {
if（col>=array2D.cols） {
throw out_of_range（"invalid col"）;
}
return const_cast<Array2D<T>&>（array2D）.array[row*array2D.cols+col];
}
const T& operator[]（unsigned int col） const {
if（col>=array2D.cols） {
throw out_of_range（"invalid col"）;
}
return array2D.array[row*array2D.cols+col];
}
};
friend class RowArray;

//get，set函数
unsigned int getRows（） const {
return rows;
}
unsigned int getCols（） const {
return cols;
}
};

template <typename T>
Array2D<T>::Array2D（unsigned int _rows, unsigned int _cols）:
rows（_rows）, cols（_cols）, array（_rows*_cols）{
for（unsigned int i=0; i<rows*cols; ++i） {
array[i]=T（）;
}
}

template <typename T>
Array2D<T>::Array2D（unsigned int _rows, unsigned int _cols, T data1, ...）:
rows（_rows）, cols（_cols）,array（_rows*_cols）{
va_list ap;
va_start（ap, _cols）;
for（unsigned int i=0; i<rows*cols; ++i） {
array[i]=va_arg（ap, T）;
}
va_end（ap）;
}

template <typename T>
Array2D<T>::RowArray Array2D<T>::operator[]（unsigned int row） {
if（row>=rows） {
throw out_of_range（"invalid row"）;
}
return RowArray（*this, row）;
}

template <typename T>
const Array2D<T>::RowArray Array2D<T>::operator[]（unsigned int row） const {
if（row>=rows） {
throw out_of_range（"invalid row"）;
}
return RowArray（*this, row）;
}

template <typename T>
ostream& operator<<（ostream& os, const Array2D<T>& array2D） {
unsigned int i, j;
for（i=0; i<array2D.rows; ++i） {
for（j=0; j<array2D.cols; ++j） {
os<<array2D.array[i*array2D.cols+j]<<"	";
}
if（i！=array2D.rows-1） {
os<<endl;
}
}
return os;
}

#endif

现在就可以使用它们了，如下面的测试程序：
#include "Array.h"
#include "Array2D.h"
#include <iostream>
#include <string>
using std::string;
using std::cout;
using std::endl;

void testArray（）;
void testArray2D（）;

int main（） {
testArray（）;
testArray2D（）;
return EXIT_SUCCESS;
}

void testArray（） {
//普通数组
Array<int> a1（3）;
cout<<"Testing Array: print 1"<<endl;
cout<<a1<<endl; //整体打印

unsigned int i;
for（i=0; i<a1.getSize（）; ++i） {
a1[i]=i+1; //逐个赋值
}
cout<<"Testing Array: print 2"<<endl;
for（i=0; i<a1.getSize（）; ++i） {
cout<<a1[i]<<"	"; //逐个打印
}
cout<<endl;

//常量数组
const Array<int> a2（3, 123, 234, 345）;
cout<<"Testing Array: print 3"<<endl;
cout<<a2<<endl;
cout<<"Testing Array: print 4"<<endl;
for（i=0; i<a2.getSize（）; ++i） {
cout<<a2[i]<<"	";
}
cout<<endl;

//拷贝构造
Array<int> a3（a1）;
cout<<"Testing Array: print 5"<<endl;
cout<<a3<<endl;
const Array<int> a4（a2）;
cout<<"Testing Array: print 6"<<endl;
cout<<a4<<endl;

//数组赋值给数组
Array<int> a5;
a5=a4;
cout<<"Testing Array: print 7"<<endl;
cout<<a5<<endl;

//增减数组元素
a5.setSize（a5.getSize（）+1）;
a5[a5.getSize（）-1]=111;
cout<<"Testing Array: print 8"<<endl;
cout<<a5<<endl;
a5.setSize（a5.getSize（）-2）;
cout<<"Testing Array: print 9"<<endl;
cout<<a5<<endl;

//保存对象
Array<string> a6（2, string（"str0"）, string（"str1"））;
cout<<"Testing Array: print 10"<<endl;
cout<<a6<<endl;
for（i=0; i<a6.getSize（）; ++i） {
a6[i]+=static_cast<char>（48+i）;
}
cout<<"Testing Array: print 11"<<endl;
for（i=0; i<a6.getSize（）; ++i） {
cout<<a6[i]<<"	";
}
cout<<endl;
const Array<string> a7（3, string（"000"）, string （"111"）, string（"222"））;
cout<<"Testing Array: print 12"<<endl;
cout<<a7<<endl;
for（i=0; i<a7.getSize（）; ++i） {
cout<<a7[i]<<"	";
}
cout<<endl;
}

void testArray2D（） {
//普通数组
Array2D<int> a1（2, 2）;
cout<<"Testing Array2D: print 1"<<endl;
cout<<a1<<endl;
unsigned int i,j;
for（i=0; i<a1.getRows（）; ++i） {
for（j=0; j<a1.getCols（）; ++j） {
a1[i][j]=i+j;
}
}
cout<<"Testing Array2D: print 2"<<endl;
for（i=0; i<a1.getRows（）; ++i） {
for（j=0; j<a1.getCols（）; ++j） {
cout<<a1[i][j]<<"	";
}
cout<<endl;
}

//常量数组
const Array2D<int> a2（2, 2, 123, 234, 345, 456）;
cout<<"Testing Array2D: print 3"<<endl;
cout<<a2<<endl;
cout<<"Testing Array2D: print 4"<<endl;
for（i=0; i<a2.getRows（）; ++i） {
for（j=0; j<a2.getCols（）; ++j） {
cout<<a2[i][j]<<"	";
}
cout<<endl;
}
//拷贝构造
Array2D<int> a3（a1）;
cout<<"Testing Array2D: print 5"<<endl;
cout<<a3<<endl;
const Array2D<int> a4（a2）;
cout<<"Testing Array2D: print 6"<<endl;
cout<<a4<<endl;

//数组赋值给数组
Array2D<int> a5;
a5=a4;
cout<<"Testing Array2D: print 7"<<endl;
cout<<a5<<endl;

//保存对象
Array2D<string> a6（2, 2, string（"str00"）, string（"str01"）, string（"str10"）, string（"str11"））;
cout<<"Testing Array2D: print 8"<<endl;
cout<<a6<<endl;
for（i=0; i<a6.getRows（）; ++i） {
for（j=0; j<a6.getCols（）; ++j） {
a6[i][j]+=static_cast<char>（48+i+j）;
}
}
cout<<"Testing Array2D: print 9"<<endl;
for（i=0; i<a6.getRows（）; ++i） {
for（j=0; j<a6.getCols（）; ++j） {
cout<<a6[i][j]<<"	";
}
cout<<endl;
}
const Array2D<string> a7（2, 1, string（"11111"）, string（"22222"））;
cout<<"Testing Array2D: print 10"<<endl;
cout<<a7<<endl;
cout<<"Testing Array2D: print 11"<<endl;
for（i=0; i<a7.getRows（）; ++i） {
for（j=0; j<a7.getCols（）; ++j） {
cout<<a7[i][j]<<"	";
}
cout<<endl;
}
}