How to rotate a dynamic array to the right? - c++

Question

I have a custom array object. It has two main variables:
m_array = Pointer to dynamic array.
m_size - The size of the array. The size for this array is 10.
When I rotate to the left, this works fine:
std::rotate(m_array + 0, m_array + 1, m_array + m_size);
This is equivalent to:
// simple rotation to the left
std::rotate(v.begin(), v.begin() + 1, v.end());
When I try rotating to the right, I'm getting a runtime error.
I need the equivalent of this:
// simple rotation to the right
std::rotate(v.rbegin(), v.rbegin() + 1, v.rend());
I tried this:
std::rotate(m_array + m_size, m_array + m_size + 1, m_array + 0);
I get the error: Invalid iterator range
So, I thought this was m_size, so I tried this:
std::rotate(m_array + m_size - 1, m_array + (m_size - 1) + 1, m_array + 0);
And I get the same error.
Thoughts are welcomed.
The source I tried to follow:
http://en.cppreference.com/w/cpp/algorithm/rotate

Answer 1

To do a right rotation (to borrow your phrase), you want the range to be everything but the last element in the array. I'll leave it to you to adapt this code to work on variable-sized arrays.
#include <algorithm>
#include <iostream>
int main() {
int data[10] = { 0, 1, 2, 3, 4,
5, 6, 7, 8, 9 };
auto print_all = [&data]() {
for(auto v: data) {
std::cout << v << ' ';
}
std::cout << '\n';
};
print_all();
// rotate elements to the left
std::rotate(data, data + 1, data + 10);
print_all();
// rotate element to the right, back to the original position
std::rotate(data, data + 9, data + 10);
print_all();
return 0;
}
My output looks like this:
./rotate
0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 0
0 1 2 3 4 5 6 7 8 9

Answer 2

The reason std::rotate(v.rbegin(), v.rbegin() + 1, v.rend()) works is that it uses reverse iterators. That means that v.rbegin() + 1 is actually decrementing the position in the array and is equal to v.begin() + v.size() - 1.
When using raw pointer arithmetic, there is no way to get the same reverse iterating behavior. You will have to manually translate the left rotation to a right rotation. This can easily be done by flipping the rotate position about the center of the array and performing a left rotate.
Left or right rotation can be boiled down to dividing an array into 2 sections and then swapping them. Whether it is a left rotation or right rotation just dictates where the division is made. For a left rotate by k, the rotation point is at k mod N. For a right rotate, the rotation point is at -k mod N where N is the total length of the array. This selects the index in the original array you would like to be at index 0 of the newly rotated array.
So the following right rotate by 1,
std::rotate(v.rbegin(), v.rbegin() + 1, v.rend())
is equivalent to using raw pointers in the following way:
int* p = &v[0];
int n = v.size();
int k = -1;
std::rotate(p, p + mod(k, n), p + n);
where mod() is the modulo operation (basically the % operator that always wraps to a positive number):
int mod(int x, int y) { return ((x % y) + y) % y; }