#include <array>
#include <string>
#include <type_traits>

template < typename T, size_t ROWS, size_t COLS >
class Matrix
{
private:
    std::array< T, ROWS * COLS > m_cValues;

public:
    Matrix( void )
    {
        m_cValues.fill( static_cast<T>( 0 ) );
    }

    ~Matrix( )
    {
    }

    explicit Matrix( std::array< T, ROWS * COLS > cValues ) : m_cValues( cValues )
    {
    }

    template < typename... Args >
    Matrix( Args ... args ) : m_cValues{ static_cast<T>( args )... }
    {
    }

    auto row( size_t iRow, Matrix< T, 1, COLS > mat ) -> void
    {
        for ( size_t i = 0; i < COLS; ++i )
            at( iRow, i ) = mat( i );
    }

    auto col( size_t iCol, Matrix< T, ROWS, 1 > mat ) -> void
    {
        for ( size_t i = 0; i < ROWS; ++i )
            at( i, iCol ) = mat( i );
    }

    auto at( size_t i ) -> T&
    {
        return m_cValues.at( i );
    }

    auto at( size_t i ) const -> const T&
    {
        return m_cValues.at( i );
    }

        auto at( size_t iRow, size_t iCol ) -> T&
    {
        return m_cValues.at( iRow * COLS + iCol );
    }

    auto at( size_t iRow, size_t iCol ) const -> const T&
    {
        return m_cValues.at( iRow * COLS + iCol );
    }

        auto operator()( size_t i ) -> T&
    {
        return at( i );
    }
};

auto main( ) -> int
{
    using Vector3 = Matrix< float, 3, 1 >;

    auto mat = Matrix< float, 3, 3 >{
        3, 5.f, 7,
        1, 0, -3,
        5, 13.0, 21,
    };

    auto v = Vector3{ 1,2,3.f };
    mat.row( 1, { 9, 6.f, 3 } );
}