#include <iostream>
#include <array>
#include <algorithm>
#include <iterator>
#include <random>

static constexpr size_t razmer = 12;

template<class T, size_t N>
struct massiv_wrapper
{
	T data[N];
};

template<class T, size_t N, class... Ts>
struct massiv_guard
{
	using massiv_type = T[N];
	
	massiv_guard(Ts&& ...args): m_ukazatel{new massiv_wrapper<T, N>(std::forward<Ts>(args)...)} {}
	~massiv_guard() { delete m_ukazatel; }
	
	massiv_type& get() { return m_ukazatel->data; }

private:
	massiv_wrapper<T, N>* m_ukazatel;
};

template<size_t N, class T>
std::ostream& operator<< (std::ostream& os, T const (&arr)[N])
{
	std::copy(std::begin(arr), std::end(arr), std::ostream_iterator<T>(os, " "));
	return os << std::endl;
}

template<size_t N, class T, class Fn>
void foreach_pair(T (&arr)[N], Fn&& f)
{
	(void)std::adjacent_find(std::begin(arr), std::end(arr), std::forward<Fn>(f));
}

int main()
{
	auto guard = massiv_guard<int, razmer>();
	int (&mas)[razmer] = guard.get();
	
	std::random_device rd;
	std::default_random_engine e1(rd());
    std::uniform_int_distribution<int> uniform_dist(0, 19);
    std::generate(std::begin(mas), std::end(mas), [&uniform_dist, &e1]() {
    	return uniform_dist(e1);
    });
    
	std::cout << mas;
	
	auto swap = [_=0](auto& a, auto& b) mutable {
		if (++_%2) { std::swap(a, b); }
		return false;
	};
	foreach_pair(mas, swap);
	
	std::cout << mas;
}