#include <fstream>
#include <vector>

typedef unsigned long ULONG;
class CMatrix
{
public:
	CMatrix(ifstream &in_file,int row,int col);    // Initialize(or construct) an matrix object with the data in a
	                                               // file, the width and the height of the matrix are both given.  
	ULONG sum();                                   // Get the summation of all the elements in the matrix.
	int s_row();                                   // Get the number of rows of the matrix, which may be trivial since 
	                                               // all the dimension information are already given as the argument of 
	                                               // constructor, but this may be more of "a member function",just a try.  
	int s_col();                                   // Get the number of the columns of the matrix.
private:
	vector<short>& base_row;      
	vector< vector<short> >& base_mat;   // Where all the elements of matrix are located.
};

CMatrix::CMatrix(ifstream &in_file, int row, int col)
{
	short val;
	while (in_file.read(reinterpret_cast<char*>(&val),sizeof(short)))
	{
		for (int rn=0; rn<row; rn++)
		{
			for (int cn=0; cn<col; cn++)
			{
				base_row.push_back(val);
			}
			base_mat.push_back(base_row);
			base_row.clear();
		}
	}
}

int CMatrix::sum()
{
	int _sum_1d = 0;
	int _sum_2d = 0;
	for (vector< vector<short> >::iterator it_2d = base_mat.begin(); it_2d<base_mat.size(); it_2d++)
	{
		for (vector<short>::iterator it_1d = base_row.begin(); it_1d<base_row.size(); it_1d++)
		{
			_sum_1d = _sum_1d + (*it_1d);  
		}
		_sum_2d = _sum_2d + _sum_1d;
	}
	return _sum_2d;
}

int CMatrix::s_row()
{
	return static_cast<int>(base_mat.size());
}

int CMatrix::s_col()
{
	return static_cast<int>(base_row.size());
}

#include <iostream>
#include <string>
#include "matrix.h"

using namespace std;

int main(int argc, char** argv)
{
	if (argc!=2)
	{
		cout<<"Input error!"<<endl;
		cout<<"matrix_class.exe in_file"<<endl;
		exit(EXIT_FAILURE);
	}
	ifstream in_file(argv[1], ios::binary);     // argv[1] is the name of the file storing 9 numbers of short type and as a result the size is 18 BYTES.
	CMatrix myMat(in_file,3,3);
	cout<<"The sum of the matrix stored in file "<<argv[1]<<" is "<<myMat.sum()<<endl;
}

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

typedef unsigned long ULONG;

class CMatrix
{
  private:
    vector<short>& base_row;
    vector< vector<short> >& base_mat;

  public:
    CMatrix(ifstream &in_file, int row, int col);
};

int main(void)
{
  return 0;
}

for (vector< vector<short> >::iterator it_2d = base_mat.begin(); it_2d<base_mat.size(); it_2d++)

for (vector< vector<short> >::iterator it_2d = base_mat.begin(); it_2d != base_mat.end(); it_2d++)

int CMatrix::sum()
{
	int _sum_1d = 0;
	int _sum_2d = 0;
	for (vector< vector<short> >::iterator it_2d = base_mat.begin(); it_2d<base_mat.size(); it_2d++)
	{
		for (vector<short>::iterator it_1d = base_row.begin(); it_1d<base_row.size(); it_1d++)
		{
			_sum_1d = _sum_1d + (*it_1d);  
		}
		_sum_2d = _sum_2d + _sum_1d;
	}
	return _sum_2d;
}

#ifndef MATRIX_H
#define MATRIX_H

// Forward declaration for vector class
class vector;

class Matrix
{
    public:
    
        // Default constructor, initializes m_rows and m_cols to 0
        Matrix();
        // Sets rows and columns
        Matrix(size_t rows, size_t cols);
        // Sets matrix
        Matrix(const std::vector<std::vector<short> >& matrix);
        // Sets rows, columns and matrix
        Matrix(const std::vector<std::vector<short> >& matrix,
               size_t rows, size_t cols);
        
        // Adds new row to matrix
        // Does not modify m_rows. setRowAmount() or
        // setDimensions() should be called after adding row
        void addRow(const std::vector<short>& row);
        
        // Sets matrix
        void setMatrix(const std::vector<std::vector<short> >& matrix);
        // Sets number of rows
        void setRowAmount(const size_t rows);
        // Sets number of columns
        void setColAmount(const size_t cols);
        // This method will set m_rows and m_cols based on
        // currently defined m_matrix
        void setDimensions();
        void setDimensions(size_t rows, size_t cols);
                
        size_t rowAmount() const;
        size_t colAmount() const;
        // Returns the total of all elements in matrix
        unsigned long sum();
        
    private:
    
        size_t m_rows;
        size_t m_cols;
        std::vector<std::vector<short> > m_matrix;
        
}; // class Matrix

#endif // MATRIX_H

#include <vector>
#include "matrix.h"

Matrix::Matrix()
    : m_rows(0), m_cols(0)
{
}

Matrix::Matrix(size_t rows, size_t cols)
    : m_rows(rows), m_cols(cols)
{
}

Matrix::Matrix(const std::vector<std::vector<short> >& matrix)
    : m_matrix(matrix)
{
}

Matrix::Matrix(const std::vector<std::vector<short> >& matrix,
               size_t rows, size_t cols)
    : m_rows(rows), m_cols(cols), m_matrix(matrix)
{
}

void Matrix::addRow(const std::vector<short>& row)
{
    m_matrix.push_back(row);
}

void Matrix::setMatrix(const std::vector<std::vector<short> >& matrix)
{
    m_matrix = matrix;
}

void Matrix::setRowAmount(size_t rows)
{
    m_rows = rows;
}

void Matrix::setColAmount(size_t cols)
{
    m_cols = cols;
}

void Matrix::setDimensions()
{
    m_rows = m_matrix.size();
    m_cols = m_matrix[0].size();
}

void Matrix::setDimensions(size_t rows, size_t cols)
{
    m_rows = rows;
    m_cols = cols;
}

size_t Matrix::rowAmount() const
{
    return m_rows;
}

size_t Matrix::colAmount() const
{
    return m_cols;
}

unsigned long Matrix::sum()
{
    using std::vector;
    
    unsigned long _sum_1d = 0;
    unsigned long _sum_2d = 0;
    for (vector<vector<short> >::iterator it_2d = m_matrix.begin(); it_2d != m_matrix.end(); it_2d++)
    {
        _sum_1d = 0;
        for (vector<short>::iterator it_1d = it_2d->begin(); it_1d != it_2d->end(); it_1d++)
        {
            _sum_1d = _sum_1d + (*it_1d);
        }
        _sum_2d = _sum_2d + _sum_1d;
    }
    return _sum_2d;
}

#include <vector>
#include <iostream>

#include "matrix.h"

int main()
{
    using std::vector;
    using std::cout;
    using std::endl;

    short rowVal = 234;
    short colVal = 2;
    short val = 0;
    unsigned long matrixSum = 0;
    
    int rows = 3;
    int cols = 3;
    
    vector<vector<short> > vectorMatrix;
    
    for (int i = 0; i < rows; i++)
    {
        vectorMatrix.push_back(vector<short>());
        for (int j = 0; j < cols; j++)
        {
            val = rowVal + colVal;
            rowVal += 2;
            colVal *= 2;
            matrixSum += val;
            cout << "val at i(" << i << "), j(" << j << ") = " << val << endl;
            vectorMatrix[i].push_back(val);
        }
    }
    
    Matrix matrixMatrix1(vectorMatrix, rows, cols);
    
    cout << "matrixSum = " << matrixSum << endl;
    cout << "matrixMatrix1.sum() = " << matrixMatrix1.sum() << endl;
    cout << endl;
    
    cout << "Creating a new matrix with Matrix()" << endl;
    Matrix matrixMatrix2;
    cout << "Using setMatrix(vector<vector<short> >) to set matrix" << endl;
    matrixMatrix2.setMatrix(vectorMatrix);
    cout << "Setting matrix dimensions with setDimensions()" << endl;
    matrixMatrix2.setDimensions();
    cout << "Number of rows is " << matrixMatrix2.rowAmount() << endl;
    cout << "Number of columns is " << matrixMatrix2.colAmount() << endl;
    cout << "Adding a new row "
    " {2, 4, 6} to matrixMatrix2 with addRow(vector<vector<short> >)" << endl;
    
    vector<short> newRow(3);
    newRow[0] = 2; newRow[1] = 4; newRow[2] = 6;
    matrixMatrix2.addRow(newRow);
    
    cout << "matrixMatrix1.sum() now " << matrixMatrix1.sum() << endl;
    cout << "matrixMatrix2.sum() now " << matrixMatrix2.sum() << endl;
    cout << "Setting new dimensions for matrixMatrix2 with setDimensions()" << endl;
    matrixMatrix2.setDimensions();
    cout << "matrixMatrix2.rowAmount() now " << matrixMatrix2.rowAmount() << endl;
    cout << "matrixMatrix2.colAmount() now " << matrixMatrix2.colAmount() << endl;
       
    return 0;
}

Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) {}

Matrix createMatrix(std::string filename, size_t rows, size_t cols);

class MatrixMaker // a "media sexy" name
{
    public:
        static Matrix createMatrix(std::string filename, size_t rows, size_t cols);
}