Simple 2D Array

I quickly hacked this together for some stuff I am writing - I havent
used the STL for a while (been programming in another language) and I'd
appreciate any feedback on how I may improve it/any gotchas (an obvious
one being if constructed with (0,0) :

#ifndef SIMPLE_2D_ARRAY_Header
#define SIMPLE_2D_ARRAY_Header

#include <vector>

template <typename T>
class Array2D
{
public:
    typedef std::vector<T> Row ;

    Array2D(const size_t numrows=1, const size_t numcols=1)
    :m_rows(numrows)
    {
        if (numrows)
        {
            for (size_t i=0; i < numrows; i++)
                m_rows[i].resize(numcols);
        }
    }

    Array2D(const Array2D& tbl)
    {
        m_rows = tbl.m_rows ;
    }

    Array2D& operator= (const Array2D& rhs)
    {
        if (this != &rhs)
            m_rows = rhs.m_rows ;

        return *this ;
    }

    ~Array2D()
    {}

    void reset(const size_t numrows, const size_t numcols)
    {
        m_rows.clear();
        m_rows.resize(numrows);

        for (size_t i = 0; i < numrows; i++)
        {
            m_rows[i].clear();
            m_rows[i].resize(numcols) ;
        }
    }

    size_t numrows() const { return m_rows.size() ; }
    size_t numcols() const { return m_rows.size() ? m_rows[0].size() : 0 ; }

    T& value_at(const size_t row, const size_t col)
    {
        if (m_rows.empty() || (row >= m_rows.size()))
            throw std::logic_error("row array bounds exceeded") ;

        if (m_rows[row].empty() || (col >= m_rows[row].size()))
            throw std::logic_error("col array bounds exceeded") ;

        return m_rows[row][col] ;
    }

    const T& value_at(const size_t row, const size_t col) const
    {
        if (m_rows.empty() || (row >= m_rows.size()))
            throw std::logic_error("row array bounds exceeded") ;

        if (m_rows[row].empty() || (col >= m_rows[row].size()))
            throw std::logic_error("col array bounds exceeded") ;

        return m_rows[row][col] ;
    }

    const std::vector<T>& row(const unsigned int index) const
    {
        if (m_rows.empty() || (index >= m_rows.size()))
            throw std::logic_error("row array bounds exceeded") ;
        return m_rows[index] ;
    }

    size_t add_col()
    {
        size_t newsize = m_rows.size() ? m_rows[0].size() + 1 : 1;

        if (newsize == 1)
        {
            Row row ;
            m_rows.push_back(row);
        }
        else
        {
            for (size_t rownum = 0; rownum < m_rows.size(); rownum++)
                m_rows[rownum].resize(newsize);
        }

        return newsize;
    }

    size_t add_row()
    {
        if (!m_rows.size())
            return 0;

        Row row(m_rows[0].size()) ;
        m_rows.push_back(row);

        return m_rows.size();
    }

private:
    std::vector<Row> m_rows ;
};

#endif

MTIA