#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>

namespace my {
    using Size = std::ptrdiff_t;
    using std::initializer_list;
    using std::vector;

    template<class Item>
    class Matrix {
    private:
        vector<Item>    items_;
        Size            n_cols_;

        auto index_for(const Size x, const Size y) const
        -> Size
        { return y * n_cols_ + x; }

    public:
        auto n_rows() const -> Size { return items_.size() / n_cols_; }
        auto n_cols() const -> Size { return n_cols_; }

        auto item(const Size x, const Size y)
        -> Item&
        { return items_[index_for(x, y)]; }

        auto item(const Size x, const Size y) const
        -> const Item&
        { return items_[index_for(x, y)];  }

        Matrix() : n_cols_(0) { }

        Matrix(const Size n_cols, const Size n_rows)
        : items_(n_cols* n_rows)
        , n_cols_(n_cols)
        {  }

        Matrix(const initializer_list<initializer_list<Item>>& values)
        : items_()
        , n_cols_(values.size() == 0 ? 0 : values.begin()->size())
        {
            for(const auto& row : values)
            {
                assert(Size(row.size()) == n_cols_);
                items_.insert(items_.end(), row.begin(), row.end());
            }
        }
    };
}

using my::Matrix;

auto some_matrix()
-> Matrix
{
	// argument list for class template "my::Matrix" is missing
    return
    {
        { 1, 2, 3, 4, 5, 6, 7 },
        { 8, 9, 10, 11, 12, 13, 14 },
        { 15, 16, 17, 18, 19, 20, 21 }
    };
}

auto main() -> int {

}