#include <algorithm>

template < typename T >
void _rotate(T *arr, int size, int step, bool right) {
	if(right)
	for(int i=0; i<size; ++i) rotate(arr[i], arr[i]+size-step, arr[i]+size);
	else
	for(int i=0; i<size; ++i) rotate(arr[i], arr[i]+step, arr[i]+size);
}

...

_rotate(matrix, 5, 2, 0); // Сдвинуть на 2 влево
_rotate(matrix, 5, 1, 1); // Сдвинуть на 1 вправо

#include <vector>
#include <algorithm>


enum Direction//перечисление сторон
{
Right = 0,
Left,
Up,
Down
};

template <typename T>
inline void shlrud(T **array, int size, int step, Direction dir)
{
vector<T> _v;//объявление вектора
for (int i =0; i < size; i++)
{
    int j;
    _v.clear();//очищаем вектор
    for (j = 0; j < size; j++)
    {
        switch (dir)
        {
            case Right:
            case Left:
            _v.push_back(array[i][j]);//забиваем в вектор строчку массива
            break;
            case Down:
            case Up:
            _v.push_back(array[j][i]);//забиваем в вектор строчку массива
            break;
        }
    }
        switch (dir)
        {
            case Right:
            case Down:
            rotate(_v.begin(),//делаем циклический сдвиг 
                _v.end()-step,//методом разворотов
                _v.end());
			break;
            case Left:
            case Up:
            rotate(_v.begin(),//делаем циклический сдвиг 
                _v.begin()+step,//методом разворотов
                _v.end());
			break;
        }
    for (j = 0; j < size; j++)
    {
        switch (dir)
        {
            case Right:
            case Left:
            array[i][j] = _v[j];//возвращаем обработанную строчку в массив
            break;
            case Down:
            case Up:
            array[j][i] = _v[j];//возвращаем обработанную строчку в массив
            break;
        }
    }
}

}

template <typename T>
void Reverse(T **Massive,int size, int StartElem, int FinishElem,int direction)
{ 	
int i,j;
T t;

	switch(direction){

		/*Горизонтально*/
		case 1:
		case -1:
		for(j=0;j<size;j++){
			for (i=0;i<=(FinishElem-StartElem)/2;i++) 
			{
                  t=Massive[j][StartElem+i]; 	 
                  Massive[j][StartElem+i]=Massive[j][FinishElem-i]; 		       
                  Massive[j][FinishElem-i]=t; 	
			} 
		}
		break;

		/*Вертикально*/
		case 2:
		case -2:
		for(j=0;j<size;j++){
			for (i=0;i<=(FinishElem-StartElem)/2;i++) 
			{
                  t=Massive[StartElem+i][j]; 	 
                  Massive[StartElem+i][j]=Massive[FinishElem-i][j]; 		       
                  Massive[FinishElem-i][j]=t; 	
			} 
		}
		break;
	}
}

template <typename T>
void cyclicShift(T **Massive, int size, int k,int direction)
{ 	
	switch(direction){

		case 1:
		case 2:
        Reverse(Massive,size,0,	size-1,	direction); //разворачиваем массив   
        Reverse(Massive,size,0,	k-1,	direction); //разворачиваем первые к элементов
		Reverse(Massive,size,k,	size-1,	direction); //разворачиваем последние n-k эллементов
		break;

		case -1:
		case -2:
        Reverse(Massive,size,0,	k-1,	direction); //разворачиваем первые к элементов
		Reverse(Massive,size,k,	size-1,	direction); //разворачиваем последние n-k эллементов
		Reverse(Massive,size,0,	size-1,	direction); //разворачиваем массив  
		break;
	}
}