I want to copy part of a vector to itself, e.g.

```
size_t offset; /* some offset */
std::vector<T> a = { /* blah blah blah */};
std::copy(a.begin() + offset, a.begin() + (offset*2), a.begin());

```

However, I'm concerned about the performance of this approach. I'd like to have this boil down to a single `memmove` (or equivalent) when the types in question allow it, but still behave as one would expect when given a non-trivially-copyable type.

When the template type `T` is trivially copyable (in particular `int64_t` if it matters), does this result in one `memmove` of length `sizeof(T) * offset`, or `offset` distinct `memmove`s of length `sizeof(T)`? I assume the later would give noticeably worse performance because it requires many separate memory reads. Or should I just assume that caching will make the performance in these situations effectively equivalent for relatively small offsets (<100)?

In cases where the template type `T` is *not* trivially copyable, is it guaranteed to result in `offset` distinct calls to the copy assignment operator `T::operator=`, or will something stranger happen?

If `std::copy` doesn't yield the result I'm looking for, is there some alternative approach that would satisfy my performance constraints without just writing template-specializations of the copy code for all the types in question?

Edit: GCC 5.1.0, compiling with -O3