BxArray.h

00001 
00008 #ifndef BxArray_H
00009 #define BxArray_H
00010 
00011 #include <memory>
00012 
00013 namespace Bx{
00014 #if defined(__BORLANDC__)
00015     #pragma warn -8027
00016 #endif
00017 
00020 template<class T>
00021 class CArray{
00022 private:
00023     T * mPointer;
00024 protected:
00025     int mSize;
00026     static int sizeT;
00027 public:
00028     inline CArray(int size){
00029         mSize = size;
00030         mPointer = new T[size];
00031     }
00032 
00033     inline CArray(const T * array, int size){
00034         mSize = size;
00035         mPointer = new T[size];
00036         for (int i = 0; i < size; i++)
00037           mPointer[i] = array[i];
00038     }
00039     
00040     CArray(int size, const T & defaultValue){
00041         mSize = size;
00042         mPointer = new T[size];
00043         if (!memcpy_s(mPointer, sizeT, static_cast<const void *>(defaultValue), size))
00044             throw std::exception("The incorrect copy operation!");
00045     }
00046     
00047     ~CArray(){
00048         delete[] mPointer;
00049     }
00050 
00051     inline T & operator[] (int row){
00052         return mPointer[row];
00053     }
00054 
00055     inline const T & operator[] (int row) const{
00056         return mPointer[row];
00057     }
00058 
00059     /*inline T * getPointer (){
00060         return mPointer;
00061     }*/
00062 
00063     inline int getSize() const{
00064       return mSize;
00065     }
00066     
00067 };
00068 
00072 template< class T>
00073 class CMatrix{
00074 private:
00075     CArray<T> ** mPointer;
00076 protected:
00077     int mRowCount;
00078     int mColCount;
00079     static int sizeT;
00080 public:
00081     CMatrix(int rowCount, int colCount){
00082         mRowCount = rowCount;
00083         mColCount = colCount;
00084         mPointer = new CArray<T>*[rowCount];
00085         for (int i = 0; i < rowCount; i++){
00086             mPointer[i] = new CArray<T>(colCount);
00087         }
00088     }
00089 
00090     CMatrix(int rowCount, int colCount, const T & defaultValue){
00091         mRowCount = rowCount;
00092         mColCount = colCount;
00093         mPointer = new CArray<T>*[rowCount];
00094         for (int i = 0; i < rowCount; i++){
00095             mPointer[i] = new CArray<T>(colCount, defaultValue);
00096         }
00097     }
00098     
00099     ~CMatrix(){
00100         for (int i = 0; i < mRowCount; i++)
00101             delete mPointer[i];
00102         delete[] mPointer;
00103     }
00104     
00105     inline const CArray<T> & operator[] (int row) const{
00106         return *mPointer[row];
00107     }
00108 
00109     inline CArray<T> & operator[] (int row){
00110         return *mPointer[row];
00111     }
00112     
00113 };
00114 #if defined(__BORLANDC__)
00115     #pragma warn +8027
00116 #endif
00117 /*template< class T> // абсолютно так же по скорости, а по безопасности хуже!
00118 class BxMatrix{
00119 private:
00120     T ** mPointer;
00121     int mRowCount;
00122     int mColCount;
00123 protected:
00124     static int sizeT;
00125 public:
00126     BxMatrix(int rowCount, int colCount){
00127         mRowCount = rowCount;
00128         mColCount = colCount;
00129         mPointer = new T*[rowCount];
00130         for (int i = 0; i < rowCount; i++)
00131             mPointer[i] = new T[colCount];
00132     }
00133     
00134     ~BxMatrix(){
00135         for (int i = 0; i < mRowCount; i++)
00136             delete[] mPointer[i];
00137         delete[] mPointer;
00138     }
00139     
00140     inline const T * operator[] (int row) const{
00141         return mPointer[row];
00142     }
00143 
00144     inline T * operator[] (int row){
00145         return mPointer[row];
00146     }
00147     
00148 };*/
00149 
00150 template< class T>
00151 int CArray<T>::sizeT = sizeof(T);
00152 
00153 } // namespace Bx
00154 
00155 #endif // BxArray_H