Matrix class in C++ - c++

Question

I need a Matrix class for a project I'm doing in C++ but I don't know how to declare the constructor.
I know I need a height and a width. But how do I go about the part where I store the values? What's the best practice?
I thought about having my constructor be:
Matrix::Matrix(int height, int width, int[] values)
and so the private attributes of my class would be height, width and? How can I say that I want to store a number of values that I don't have yet?
I hope this makes sense... I'm finding it very hard to explain and that's probably because I'm very confuse. I'm very new with C++, so any extra help will be appreciated.

Answer 1

Just for an illustration list of constructors for OpenCV's cv::Mat class:
// constructors
Mat();
// constructs matrix of the specified size and type
// (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
Mat(int _rows, int _cols, int _type);
Mat(Size _size, int _type);
// constucts matrix and fills it with the specified value _s.
Mat(int _rows, int _cols, int _type, const Scalar& _s);
Mat(Size _size, int _type, const Scalar& _s);
// copy constructor
Mat(const Mat& m);
// constructor for matrix headers pointing to user-allocated data
Mat(int _rows, int _cols, int _type, void* _data, size_t _step=AUTO_STEP);
Mat(Size _size, int _type, void* _data, size_t _step=AUTO_STEP);
// creates a matrix header for a part of the bigger matrix
Mat(const Mat& m, const Range& rowRange, const Range& colRange);
Mat(const Mat& m, const Rect& roi);
// converts old-style CvMat to the new matrix; the data is not copied by default
Mat(const CvMat* m, bool copyData=false);
// converts old-style IplImage to the new matrix; the data is not copied by default
Mat(const IplImage* img, bool copyData=false);
// builds matrix from std::vector with or without copying the data
template<typename _Tp> explicit Mat(const vector<_Tp>& vec, bool copyData=false);
// helper constructor to compile matrix expressions
Mat(const MatExpr_Base& expr);
// assignment operators
Mat& operator = (const Mat& m);
Mat& operator = (const MatExpr_Base& expr);
I think this is good place to get inspiration or use it for your project, hover I'd recommend following constructors:
// Will declare whether to fill allocated data with zeros, ones or leave it be
enum MatrixFill { NO_INITIALIZATION, ZERO_FILL, ONES_FILL};
Matrix( const int width, const int height, const MatrixFill fill = NO_INITIALIZATION);
// To initialize from T data[] = {1,2,3,1,2,3,1,2,3};
Matrix( const int width, const int height, const T *data);
// To initialize from T data[][3] = {{1,2,3},{1,2,3},{1,2,3}};
Matrix( const int width, const int height, const T **data);
// To initialize from other matrix
Matrix( const Matrix &orig);
// Don't forget assign operator
Matrix &operator=(const Matrix &orig);
I'd also create type SubMatrix which wouldn't contain any data just link to parent data and range which would allow you to do this:
Matrix my( old.getSubMatrix( row, col, rowsCount, colsCount));
// And of course it'd have constructor like this:
Matrix( const SubMatrix &orig);
You may add many more constructors but I'd start with those five. Ask questions if you have any.

Answer 2

I'd learn from the pros: http://www.boost.org/doc/libs/1_48_0/libs/numeric/ublas/doc/matrix.htm#matrix

Answer 3

You should probably have a number of constructors, based on how you expect to use the class.
Assuming you plan to use Matrix for some kind of linear algebra, you should have a constructor which initializes the elements to zero:
Matrix(int height, int width); // initializes elements to 0
You should have constructors that initialize the elements from whatever data source you expect to find convenient (below, the type T is the element type of your Matrix):
Matrix(int height, int width, const std::vector<T> &data); // init from vector
Matrix(int height, int width, const T *data); // init from array
If you want to be able to declare an array of matrices, you need a default constructor:
Matrix(); // uninitialized or default array (to be initialized later)
You should also either define or disable copy constructors and assignment operators (or C++ will define them for you, badly):
Matrix(const Matrix &orig); // copy constructor
Matrix& operator=(const Matrix &orig); // assignment operator

Answer 4

I would really try to look for a book about OO design and their application in C++. As this question (besides hard to understand) shows a general misunderstanding of how object oriented languages work. I could explain it here in this topic; but that would be redundant and book authors can do it much better than me.
Basically what I understood from this question is that you know the sizes of your matrix, yet don't know the values they will get when you create them?
In that case simply make a constructor with only the sizes. And initialize the matrix to some "NULL" value. (Possibly even set a private member to false, indicating it isn't completely usable yet). The class and constructor would look like:
class Matrix() {
public:
Matrix(int nRows, int nColumns);
private:
int numRows;
int numColums;
std::vector<VALUE_TYPE> val;
};
Matrix::Matrix(int nRows, int nColums) {
int numRows = nRows;
int numColumns = nColums;
std::vector<VALUE_TYPE> val(nRows * nColums);
}
Simply said: the constructor only makes sure the memory is "allocated". Then you use other functions to fill in the actual values.
If you wish to provide "something", where you don't know exactly what "something" is. But you do know it is a container of data - you should use standard iterators (or templates). This is the manner how c++ handles inserting of data to standard containers. The function would be like this:
template <typename InIt>
Matrix::Matrix(int nRows, int nColums, InIt begin, InIt end) {
int numRows = nRows;
int numColumns = nColums;
//[begin, end) now holds the data - manipulate it at will.
std::vector<VALUE_TYPE> val(begin, end);
val.resize(nColums * nRows);
}
But once again: I'd take a book as the question to me seems unclear and answered by books.

Answer 5

Not strictly related to cpstructors but ... are you matrix expected to be resized during their life? If not, consider the idea not to have numRows and numCols as "variables" (they will never vary) but as template parameters.
Your matrix can be so declared as
Matrix<int,3,3> a; //a 3x3 integers
Matrix<double,3,2> a; //a 3x2 doubles
This will let impossible operations (like adding matrix with different sizes) impossible to compile.