A Slice-type for C++
This looks pretty good. 

Use mem-initializer lists

When you write

slice(T* array, size_t length) {
    this-&gt;m_array  = array;
    this-&gt;m_length = length;
}


you're default constructing m_array and m_length and then assigning them. For pointers and integral types, this isn't exactly expensive, but it's a waste and may as well not get into that habit. Prefer directly constructing:

slice(T* array, size_t length)
: m_array(array)
, m_length(length)
{ }


Your other constructor can on the one hand just delegate to this one:

slice(T* array, size_t length, size_t skip)
: slice(array + skip, length)
{ }


but on the other hand doesn't really need to exist anyway. Just let the user pass in where he wants to start. This strikes me as just bloaty. 

const functions

size() should be const, and you're missing T const&amp; operator[](size_t) const. 

You could also provide a T* data() and T const* data() const, which in this case just alias begin().

Additionally, consider providing a different constructor so that I can construct a slice&lt;const T&gt; from a slice&lt;T&gt;. That's something that makes sense. 

throwing

If you're throwing due to out of range indexing, you should throw std::out_of_range. But generally, avoid having operator[] throw. This is what you're going to use most often so it's best to make it as simple as possible. If you want to provide a throwing alternative, the typical pattern followed by the standard library is to provide an at() function that does the bounds checking and then forwards along to operator[]. 

constexpr

Everything here can be constexpr. Just go overboard.