Одномерный массив. Циклический сдвиг вправо

#include <iostream>
#include <iomanip>
#include <ctime>
#include <cmath>
#include <memory.h>
 
int * ShiftR(int *arr,int size, int shift){
    if(shift<0) return arr;
    shift=shift%size;
    int *temp=new int[shift];
    memcpy(temp,arr+size-shift,shift*sizeof(*arr));
    memmove(arr+shift,arr,(size-shift)*sizeof(*arr));
    memcpy(arr,temp,shift*sizeof(*arr));
    delete [] temp;
    return arr;
}
 
int * ShiftL(int *arr,int size, int shift){
    if(shift<0) return arr;
    shift=shift%size;
    int *temp=new int[shift];
    memcpy(temp,arr,shift*sizeof(*arr));
    memmove(arr,arr+shift,(size-shift)*sizeof(*arr));
    memcpy(arr+size-shift,temp,shift*sizeof(*arr));
    delete [] temp;
    return arr;
}
 
 
int * Shift(int *arr,int size, int shift){
    if (shift<0) return ShiftL(arr,size,std::abs(shift));
    if (shift>0) return ShiftR(arr,size,shift);
    return arr;
}
 
int main(){
    const int size=10;
    int arr[size];
    std::srand(std::time(NULL));
    for(int i=0;i<size;++i){
        std::cout<<std::setw(3)<<(arr[i]=std::rand()%90+10);
    }
    std::cout<<std::endl;
 
    ShiftL(arr,size,1);
    ShiftR(arr,size,2);
 
    Shift(arr,size,-1);
    Shift(arr,size,2);
 
    for(int i=0;i<size;++i){
        std::cout<<std::setw(3)<<arr[i];
    }   
    std::cin.get();
    return 0;
}

#include <iostream>
#include <locale>
 
using namespace std;
 
const int size=8; //Задание величины массива
int const sdvig_size(); //Функция для задания величины сдвига
void sdvig_f(int a, int b, int usl, int center, int *mass2); //Функция, меняющая местами части массива
void buffer(int &mass_i, int &mass_j); //Функция, меняющая местами заданные элементы массива
void print(int *mass2); //Функция вывода всего массива на экран
 
int main()
{
    setlocale(LC_ALL,"Russian");
    cout<<"-->Программа сдвига массива вправо или влево на заданную величину<--"<<endl;
 
    //Задание исходного массива и его вывод на экран:
    int mass[size]={1, 2, 3, 4, 5, 6, 7, 8};
    int i, j;
    cout<<endl<<"Исходный массив:"<<endl;
    print(mass);
 
    //Создание управляющего меню
    int option;
    cout<<endl<<"В какую сторону будем сдвигать массив?"<<endl;
    cout<<"1. Влево"<<endl;
    cout<<"2. Вправо"<<endl;
    do
    {
        cout<<endl<<"Введите нужный вариант: ";
        cin>>option;
    }
    while (option<1 || option>2); //Пока пользователь не нажмёт цифру от 1 до 2 программа дальше работать не будет
 
    switch (option)
    {
    case 1:
        {
            //Задаем сдвиг:
            const int sdvig=sdvig_size();
            //1) Переворачиваем левую часть:
            sdvig_f(0, (sdvig-1), (sdvig/2), sdvig%2, mass);
            cout<<"Переворот левой части:"<<endl;
            print(mass);
            
            //2) Переворачиваем правую часть:
            sdvig_f(sdvig, (size-1), (sdvig+((size-sdvig)/2)), (size-sdvig)%2, mass);
            cout<<"Переворот правой части:"<<endl;
            print(mass);
 
            //3) Переворачиваем весь массив:
            sdvig_f(0, (size-1), (size/2), size%2, mass);
            cout<<"Переворот всего массива:"<<endl;
            print(mass);
        }
        break;
    case 2:
        {
            //Задаем сдвиг:
            const int sdvig=sdvig_size();
            //1) Переворачиваем левую часть:
            sdvig_f(0, ((size-sdvig)-1), ((size-sdvig)/2), (size-sdvig)%2, mass);
            cout<<"Переворот левой части:"<<endl;
            print(mass);
    
            //2) Переворачиваем правую часть:
            sdvig_f((size-sdvig), (size-1), ((size-sdvig)+(sdvig/2)), sdvig%2, mass);
            cout<<"Переворот правой части:"<<endl;
            print(mass);
 
            //3) Переворачиваем весь массив:
            sdvig_f(0, (size-1), (size/2), size%2, mass);
            cout<<"Переворот всего массива:"<<endl;
            print(mass);
        }
        break;
    }
    cout<<endl;
 
    system("pause"); 
    return 0;
}
 
//Задание сдвига:
int const sdvig_size()
{
    int a;
    cout<<"Введите сдвиг: ";
    cin>>a;
    return a;
}
 
//Меняем местами части массива:
void sdvig_f(int a, int b, int usl, int center, int *mass2)
{
    int i;
    int j;
    if (center==0)
    {
        for(i=a, j=b; i!=usl; i++, j--) buffer(mass2[i], mass2[j]);
    }
    else
    {
        for(i=a, j=b; i!=j; i++, j--) buffer(mass2[i], mass2[j]);
    }
}
 
//Меняем местами заданные элементы массива
void buffer(int &mass_i, int &mass_j)
{
    int buf=mass_i;
    mass_i=mass_j;
    mass_j=buf;
}
 
//Вывод всего массива на экран:
void print(int *mass2)
{
    int i;
    for(i=0; i<size; i++)
    {
        cout<<mass2[i]<<" ";
    }
    cout<<endl;
}

template <typename IT> void swap_blocks(IT b, IT m, IT e)
{ // В диапазоне [b, e) обмениваем местами поддиапазоны [b, m) и [m, e)
  if (m == b)
    return;
 
  while (e != m)
  {
    size_t n_left = m - b, n_right = e - m;
    if (n_left <= n_right)
    {
      std::swap_ranges(b, m, e - n_left);
      e -= n_left;
    }
    else
    {
      std::swap_ranges(b, b + n_right, m);
      b += n_right;
    }
  }
}

int main()
{
  const int N = 8;
  const int K = 3;
  int A[N] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
  std::copy(std::begin(A), std::end(A), std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
 
  swap_blocks(A, A + N - K, A + N);
 
  std::copy(std::begin(A), std::end(A), std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;
}

void shift_right(int a[], size_t n, size_t k)
{ 
  int buffer[4];
  assert(k < n && k < sizeof buffer / sizeof *buffer);
 
  std::copy(a + n - k, a + n, buffer);
  std::copy_backward(a, a + n - k, a + n);
  std::copy(buffer, buffer + k, a);
}