multidimensional array of C++

mArray.hpp

#ifndef _MARRAY_H_
#define _MARRAY_H_

#include <fstream>
#include <iostream>
#include "cv.h"
namespace BSPL {

  // 1D array class with overloading operations
  template <class T, int Size>
  class Array {
  public:
    typedef T S;
    const static int size = Size;
  protected:
    T *data;    
    CvMat m;
  public:
    //allocate
    void set_header(const T *h) { 
      data = const_cast<T*>(h);
      m = cvMat(1, Size, CV_64FC1, data);
    }
    void allocate() { 
      data = new T [size];
      m = cvMat(1, Size, CV_64FC1, data);
    }
    void deallocate() { if (data) delete [] data;}

    const CvMat &mat() const { return m;}
    CvMat &mat() {return m;}
    const CvMat &vec() const { return m;}
    CvMat &vec() {return m;}

    //constructer    
    Array () {};
    Array (const T &v) 
    { allocate(); for (int i=0;i<Size;++i) data[i] = v;};
    Array (const S* v) 
    { allocate(); for (int i=0;i<Size;++i) data[i] = v[i];};
    Array (const Array &r) 
    { allocate(); for (int i=0;i<Size;++i) data[i] = r.data[i];};
  //~Array () {deallocate();}

    // overloading operators
    Array& operator= (const Array &r) 
    { for (int i=0;i<Size;++i) data[i] = r.data[i]; return *this;}
    Array& operator+= (const Array &r) 
    { for (int i=0;i<Size;++i) data[i] += r.data[i]; return *this;}
    Array& operator-= (const Array &r) 
    { for (int i=0;i<Size;++i) data[i] -= r.data[i]; return *this;}
    Array& operator*= (const double &n) 
    { for (int i=0;i<Size;++i) data[i] *= n; return *this;}
    Array& operator/= (const double &n) 
    { for (int i=0;i<Size;++i) data[i] /= n; return *this;}


    T& operator[] (int i) {return data[i];}
    const T& operator[] (int i) const {return data[i];}

    // conversion operator
    operator const S*&() const {return data;}
    operator S*&() {return data;}

	// set value
	void set(const T &v) {
		for (int i=0;i<Size;++i) data[i] = v;
    }

  };

  // multi-dimensional array class 
  template <class T, int Size> 
  class mArray {
  public:
    typedef typename T::S S;
    const static int size = Size * T::size;
  protected:
    T data[Size];
    S *s_data;
    CvMat m; CvMat m1;    
  public:
    //allocate
    void set_header(const S *h) { 
      s_data = const_cast<S*>(h);
      for (int i=0;i<Size;++i) {
	data[i].set_header(s_data+i*T::size);
      }
      m = cvMat(Size, size/Size, CV_64FC1, s_data);
      m1 = cvMat(1, size, CV_64FC1, s_data);
    }

    void allocate() {
      S* tmp = new S [size];
      set_header(tmp);
    }
    void deallocate() {
	  // Delete ONLY once
      if (s_data) delete [] s_data;
    }

    const CvMat &mat() const { return m;}
    CvMat &mat() {return m;}
    const CvMat &vec() const { return m1;}
    CvMat &vec() {return m1;}

    //constructer    
    mArray () {};
    mArray (const S &v) 
    { allocate(); for (int i=0;i<size;++i) s_data[i] = v;};
    mArray (const S* v)
    { allocate(); for (int i=0;i<size;++i) s_data[i] = v[i];};
    mArray (const T &v) 
    { allocate(); for (int i=0;i<Size;++i) data[i] = v;};
    mArray (const mArray &r) 
    { allocate(); for (int i=0;i<Size;++i) data[i] = r.data[i];};
	//~mArray () {deallocate();}

    // overloading operators
    mArray& operator= (const mArray &r) 
	{ for (int i=0;i<Size;++i) data[i] = r.data[i]; return *this;}
    mArray& operator+= (const mArray &r) 
    { for (int i=0;i<Size;++i) data[i] += r.data[i]; return *this;}
    mArray& operator-= (const mArray &r) 
    { for (int i=0;i<Size;++i) data[i] -= r.data[i]; return *this;}
    mArray& operator*= (const double &n) 
    { for (int i=0;i<Size;++i) data[i] *= n; return *this;}
    mArray& operator/= (const double &n) 
    { for (int i=0;i<Size;++i) data[i] /= n; return *this;}

    T& operator[] (int i) {return data[i];}
    const T& operator[] (int i) const {return data[i];}
    
    // conversion operator
    operator const S*&() const {return s_data;}
    operator S*&() {return s_data;}

	// set value
	void set(const T &v) {
		for (int i=0;i<Size;++i) data[i] = v;
    }

  };


  template <class T, int Size>
  std::istream &operator>> (std::istream &in, Array<T,Size> & a) {
    for (int i=0; i<Size; ++i)
      in >> a[i];
    return in;
  }

  template <class T, int Size>
  std::istream &operator>> (std::istream &in, mArray<T,Size> & a) {
    for (int i=0; i<Size; ++i)
      in >> a[i];
    return in;
  }

  template <class T, int Size>
  std::ostream &operator<< (std::ostream &out, Array<T,Size> & a) {
    out << "[";
    for (int i=0; i<Size-1; ++i)
      out << a[i] << " ";
    out << a[Size-1] << "]";
    return out;
  }

  template <class T, int Size>
  std::ostream &operator<< (std::ostream &out, mArray<T,Size> & a) {
    out << "[";
    for (int i=0; i<Size-1; ++i)
      out << a[i] << "\n ";
    out << a[Size-1] << "]\n";
    return out;
  }
  

}

#endif /* _MARRAY_H_ */