Programming

#include <iostream>
#include <vector>
using namespace std;

template <typename T>
class Matrix {
protected:
  std::vector<std::vector<T> > m_data;
public:
  Matrix() {}
  Matrix(int rows, int cols) : m_data(rows, std::vector<T>(cols)) {}
  ~Matrix() {}

  inline void get_size(int& rows, int& cols) {
    rows = m_data.size();
    cols = m_data[0].size(); }
  //operators
  inline std::vector<T> & operator[](int i) { return m_data[i]; }
  inline const std::vector<T> & operator[] (int i) const { return m_data[i]; }
};

template <typename T>
class MatrixTD {
protected:
  Matrix<std::vector<T> > m_data; 
  
public:
  MatrixTD() {}
  MatrixTD(int rows, int cols, int lays) : m_data(rows, cols) {
    for(int i = 0; i < rows; ++i)
      for(int j = 0; j < cols; ++j)
	m_data[i][j].resize(lays); }
  MatrixTD(int rows, int cols, int lays, T val) : m_data(rows, cols) {
    for(int i = 0; i < rows; ++i){
      for(int j = 0; j < cols; ++j){
	m_data[i][j].resize(lays);
	for(int k = 0; k < lays; ++k)
	  m_data[i][j][k] = val;
      }
    } }
  ~MatrixTD() {}
  
  inline void get_size(int& rows, int& cols, int& lays) {
    m_data.get_size(rows, cols);
    lays = m_data[0][0].size(); }
  //operators
  inline std::vector<T> & operator[](int i) { return m_data[i]; }
  inline const std::vector<T> & operator[] (int i) const { return m_data[i]; }
};

int main(){
  int size = 5;
  int s1, s2, s3;
  MatrixTD<int> m3Dd(size, size, size, 0);
  m3Dd.get_size(s1, s2, s3);
  for(int i = 0; i < s1; ++i){
    for(int j = 0; j < s2; ++j){
      for(int k = 0; k < s3; ++k){
	cout<<m3Dd[i][j][k]<<" ";
      }
      cout<<endl;
    }
    cout<<endl;
  }

  return 0;
}

inline T  & operator()(int i, int j, int k) { return m_data[i][j][k]; }