#include <iostream>
#include <string>
#include <array>
#include <algorithm>
#include <utility>
#include <iterator>

static const size_t SQUARE_DIMENSION = 4;
using square_t = std::array<std::string, SQUARE_DIMENSION>;

template <typename F>
void repeat(unsigned n, F f) {
    while (n--) f();
}

inline square_t read_square(std::istream &in){
    square_t out;
    
    std::generate_n( std::begin(out), SQUARE_DIMENSION, [&](){
        std::string line;
        getline(in, line);
        return std::move( line ); 
    });

    return std::move( out );
}

inline square_t& rotate(square_t &in){

    for (size_t i = 0; i < SQUARE_DIMENSION; i++) {
        for (size_t j = i; j < SQUARE_DIMENSION; j++) {
            std::swap( in[i][j], in[j][i] ); 
        }
    }


    for(size_t i = 0; i < SQUARE_DIMENSION/2; i++) {
        for(size_t j = 0; j < SQUARE_DIMENSION; j++) {
            std::swap( in[j][i], in[j][SQUARE_DIMENSION - i - 1] );
        }
    }
    
    return in;
}


inline std::string merge(const square_t &ciphered, const square_t &grille){
    std::string out;

    for (size_t i = 0; i < SQUARE_DIMENSION; i++){
        for (size_t j = 0; j < SQUARE_DIMENSION; j++){
            if ( grille[i][j] == 'X' )
                out += ciphered[i][j];
        }
    }
    

    return std::move( out );
}


int main()
{
    auto grille     = read_square( std::cin );
    auto ciphered   = read_square( std::cin );


    repeat(4, [&](){
        std::cout << merge( ciphered, grille );
        rotate(grille);
    });

    return 0;
}

S&& append(S&& obj, const T& diff) {
  obj.apply(diff);
  return std::move(obj);
}

M>template <typename F>
M>void repeat(unsigned n, F f) {
M>    while (n--) f();
M>}
M>

template <typename F>
void repeat (usnsigned n, F&& f) {
    while (n--) f();
}

M>Давненько я не брал в руки плюсы...

M>Буду признателен за критику кода решения задачки http://acm.timus.ru/problem.aspx?space=1&num=1712

#include <stdio.h>
#include <stdlib.h>

enum { N=4, NN=N*N };
int rot(int c) { return N*(c%N)+N-1-c/N; }
int cmp(const void* a, const void* b){ return *(int*)a - *(int*)b; }
void sort(int *x,int n) { qsort(x,n,sizeof(*x),cmp); }
void read(char* s) {
    int x,y,i,j; enum { line_max=80 }; char line[line_max];
    for(i=0,y=0;y<N;y++) {
        fgets(line,line_max,stdin);
        for(j=0,x=0;x<N;x++) {
            s[i++]=line[j];
            if (line[j]) j++;
        }
    }    
}
int main(int argc,char** argv) {
    int i,j, nxy, xy[NN]; char s[NN];
    read(s); 
    nxy=0; for(i=0;i<NN;i++) if (s[i]=='X') xy[nxy++]=i;
    read(s);     
    for(i=0;i<4;i++) {
        for(j=0;j<nxy;j++) { 
            putc(s[xy[j]],stdout);
            xy[j]=rot(xy[j]);
        }
        sort(xy,nxy);
    }
    putc('\n',stdout);
    return 0;
}

PM>И repeat можно сделать проще, написав обычный цикл for, знакомый 100% читателей

5*[]{ 
    std::cout << "HELLO WORLD";
}

S>А на RVO есть хоть какая-то гарантия? Вроде же там как левая пятка компилятора захочет

class Obj {
private:
    Obj(int); 
public:
    Obj(Obj&&) = delete;
    Obj(const Obj&) = delete;
};

Obj CreateObj() { 
  return Obj(4);  // нельзя до C++17
}