#include <vector>
#include <utility>
#include <iostream>

template <typename T>
class Matrix {

private:

    class Row {
        friend class Matrix;

    public:
        T& operator[] (int j)&&
        {
            return matrix.mappedVector[i * matrix.n + j];
        }
        const T& operator[] (int j) const&&
        {
            return matrix.mappedVector[i * matrix.n + j];
        }
    private:
        int i;
        Matrix& matrix;

        Row(int i, Matrix& matrix) :  i(i),   matrix(matrix) {
            std::cout << "int ctor" << std::endl;
        }

        Row() {
            std::cout << "ctor" << std::endl;
        }

    };
public:
    Matrix() :
        m(0),
        n(0)
    {}
    explicit Matrix(size_t m, size_t n) :   m(m),   n(n),   mappedVector(m* n){
    }


    Row operator[] (int i) {
        return Row(i, *this);
    }

    const Row operator[] (int i) const  {
        return Row(i, *this);
    }

private:
    size_t m;
    size_t n;
    std::vector<T> mappedVector;
};

int main()
{
    Matrix<int> matrix(2, 5);
    matrix[1][0] = 1;

    auto autoRowProxy = matrix[1];

    return 0;
}