Matrix OOP implementation using C++11 and C++14
Lets start from the usage:


It is not possible to write range loops with the current version
no rowcount() and columncount() (or anything similar). So it is not possible to actually traverse matrix
operator[]() won't work on const objects, since there is no operator[](std::size_t index) const.


Clarity and cleanliness:


nuke pimpl. I'm serious, it doesn't add much benefit here. In fact, the compilation might be increased by pimpl, since matrix is very lightweight anyway.
#include &lt;iostream&gt; header is not needed, should be removed.
double indirection. _impl should actually be MatrixRow. But if pimpl is gonna get nuked, it will be embedded into matrix itself.
std::vector&lt;&gt; would be much better fit here.

Nitpicks:
destructor is generated for you automatically. defaulting it is redundant.


Some general guidelines:


OOP is usually mixed with some functional programming in C++. For example, templates.
C++ code usually tries to provide some default behavior that is correct and safe, and some access to underlying implementation that when accessed lets programmer to take all of the control to himself (literally everything).


Recommendation for next iteration:

I think that std::vector&lt;T&gt; will be the best fit here. Calculating the index to jump at should be pretty easy (it is what compiler does for us anyway). I think it will be okay to return T* from operator[](), because users know they shouldn't mess with it, but making some small struct would good as well. Something like std::array_view&lt;T&gt; would be nice (though it seems like it is not in the standard yet, even in C++17). Also, you get iterators for free with vector approach. 

Just write:

auto begin()
{
    return storage.begin();
}

auto end()
{
    return storage.end();
}


As a result, you get range loop for free as well.