CODEWITHSUNDEEP
c++classmemoryallocation
programming
programming

Reputation: 41

How to allocate a matrix in C++?

For a vector in C++, I have

class Vec 
{
public:
  int len;
  double * vdata;
  Vec();
  Vec(Vec const & v) 
  {
    cout<<"Vec copy constructor\n";
    len = v.len;
    vdata=new double[len];
    for (int i=0;i<len;i++) vdata[i]=v.vdata[i];
  };

I would greatly appreciate it if you could help me how to write an analogous code for a matrix. I am thinking something like this:

class Mat
{
public:

  int nrows;
  int ncols;
  double * mdata;
  Mat();
  Mat(Mat const & m) 
  {
    cout<<"Mat copy constructor\n";
    nrows = m.nrows;
    ncols = m.ncols;

But I don't know how to code the memory allocation for a matrix using the idea that first we put all the elements into a 1D array (row1 row2 ... rown) then we chop the array into rows and then chop each row into columns. Particularly, could you help me translate this idea into C++ language that is analogous to the following: 

 vdata=new double[len];
 for (int i=0;i<len;i++) vdata[i]=v.vdata[i];
  };

I am thinking of something like this:

double *data=new double[nrows*ncols];
for (int i=0;i<nrows;i++) 
{
   for (int j=0;j<ncols,j++){data(i,j)=m.mdata[i][j]};
};

But I am not sure about this part: 

data(i,j)=m.mdata[i][j]

Also, I am supposed to use a pure virtual element indexing method: the (i,j) element of a Mat object m will be retrieved by m(i,j). I have to provide both const and non-const versions of this indexing operator.<-- May you show me how I could do this?

Thanks a lot.

Upvotes: 4

Views: 276

Answers (2)

Wilbert
Wilbert

Reputation: 7399

Use as a single-dimensional array. You will notice that in practice, it's generally much simpler to use a 1d-array for such things.

class Matrix
{
public:
    Matrix(unsigned int rows, unsigned int cols)
        : _rows(rows)
        , _cols(cols)
        , _size(_rows*_cols)
        , _components(new double[_size])
    {
        for(unsigned int i = 0; i < _size; ++i)
        {
            _components[i] = 0;
        }
    }

    ~Matrix()
    {
        delete[] _components;
    }

    double& operator()(unsigned int row, unsigned int col)
    {
         unsigned int index = row * _cols + col;
         return _components[index];
    }

private:
    unsigned int _rows;
    unsigned int _cols;
    unsigned int _size;
    double* _components;    
};

However, if you want to actually use matrices and vectors, and not just implement them for learning, I would really advise you to use the Eigen library. It's free and open source and has great and easy-to-use vector and matrix classes.

While Eigen is great to use, if you want to look at source code of an existing implementation, it can be quite confusing for new programmers - it's very general and contains a lot of optimizations. A less complicated implementation of basic matrix and vector classes can be found in vmmlib.

Upvotes: 4

Michael
Michael

Reputation: 1503

Also you can use one standard vector to implement matrix but vector size will be nrows * ncols:

#include <vector>
class Mat {
  public:
    Mat(int rows, int cols): 
      nrows(rows), 
      ncols(cols), 
      elems(rows*cols,0) 
    {}

    Mat(const Mat &m): 
      nrows(m.nrows), 
      ncols(m.ncols), 
      elems(m.elems.begin(), m.elems.end()) 
    {}

    double celem(int i,int j) const {
      return elems[ncols*i + nrows*j];
    }

    double *pelem(int i,int j) {
      return &elems[ncols*i + nrows*j];
    }

  private:
    int nrows;
    int ncols;
    vector<double> elems;
};

Upvotes: 1

Related Questions