Enigma (Macchina Tedesca )

#include <iostream>
#include <string>
#include <stdio.h>
#include <ctype.h>
using namespace std;
/*
    Titolo : Una macchina Enigma virtuale ( Crittografia Tedesca );
    ///////////////////////////////////////////////////////////////
    Autore : Diego Oprea;
    /////////////////////
    Data Inizio : 25/01/2020
    /////////////////////////
    Problemi :
    ////////////////////////////////////////////////
    Data Completamento : 29/01/2020
*/
int main()
{
    // Dichiarazione dei rotori //
    char iniziale[26]  {'Q','W','E','R','T','Z','U','I','O','A','S','D','F','G','H','J','K','P','Y','X','C','V','B','N','M','L'};
    char r_destro [26] [2]      {{'A','Q'},
                                 {'V','W'},
                                 {'O','E'},
                                 {'E','R'},
                                 {'Y','T'},
                                 {'F','Z'},
                                 {'W','U'},
                                 {'L','I'},
                                 {'D','O'},
                                 {'Q','A'},
                                 {'C','S'},
                                 {'B','D'},
                                 {'S','F'},
                                 {'P','G'},
                                 {'T','H'},
                                 {'K','J'},
                                 {'R','K'},
                                 {'G','P'},
                                 {'I','Y'},
                                 {'J','X'},
                                 {'U','C'},
                                 {'H','V'},
                                 {'X','B'},
                                 {'Z','N'},
                                 {'M','M'},
                                 {'N','L'}};
    char r_centro [26] [2]      {{'Y','Q'},
                                 {'U','W'},
                                 {'F','E'},
                                 {'H','R'},
                                 {'X','T'},
                                 {'Z','Z'},
                                 {'M','U'},
                                 {'N','I'},
                                 {'J','O'},
                                 {'G','A'},
                                 {'O','S'},
                                 {'P','D'},
                                 {'A','F'},
                                 {'Q','G'},
                                 {'I','H'},
                                 {'R','J'},
                                 {'L','K'},
                                 {'D','P'},
                                 {'T','Y'},
                                 {'W','X'},
                                 {'V','C'},
                                 {'K','V'},
                                 {'S','B'},
                                 {'B','N'},
                                 {'C','M'},
                                 {'E','L'}};
    char r_sinistro [26] [2]       {{'S','Q'},
                                    {'T','W'},
                                    {'I','E'},
                                    {'O','R'},
                                    {'F','T'},
                                    {'M','Z'},
                                    {'Y','U'},
                                    {'Z','I'},
                                    {'E','O'},
                                    {'Q','A'},
                                    {'D','S'},
                                    {'L','D'},
                                    {'B','F'},
                                    {'C','G'},
                                    {'K','H'},
                                    {'J','J'},
                                    {'G','K'},
                                    {'V','P'},
                                    {'P','Y'},
                                    {'U','X'},
                                    {'R','C'},
                                    {'W','V'},
                                    {'N','B'},
                                    {'X','N'},
                                    {'A','M'},
                                    {'H','L'}};
    char riflettore      [26] [2]  {{'K','Q'},
                                    {'M','W'},
                                    {'I','E'},
                                    {'H','R'},
                                    {'U','T'},
                                    {'G','Z'},
                                    {'T','U'},
                                    {'E','I'},
                                    {'V','O'},
                                    {'J','A'},
                                    {'C','S'},
                                    {'L','D'},
                                    {'X','F'},
                                    {'Z','G'},
                                    {'R','H'},
                                    {'A','J'},
                                    {'Q','K'},
                                    {'N','P'},
                                    {'B','Y'},
                                    {'F','X'},
                                    {'S','C'},
                                    {'O','V'},
                                    {'Y','B'},
                                    {'P','N'},
                                    {'W','M'},
                                    {'D','L'}};

    // Variabili //
    string parola;
    int length_parola = 0; // Lunghezza di stringa parola //
    int x=0, a=0, j=0, k=0; // x=posizione lettera vari rotori; a=posizione lettera di parola; j e k = cicli for per shift //
    short int cont_rd = 0, cont_rc = 0;
    bool verifica = false;
    char shift [2];

    // Inserimento parola //
    cout<<"Inserisci parola:"<<endl;
    cin >> parola;
    length_parola = parola.length(); // Calcolo lunghezza di stringa parola //
    /*cout<<"Lunghezza parola: " << length_parola <<endl;*/
    for(int v=0;v<length_parola;v++)
    {
        parola[v] = toupper(parola[v]); // carratteri piccoli li fa grandi //
    }

    cout<<"messaggio cifrato:"<<endl;
    // Crittografia //
    do{
        /* DA INIZIALE A RIFLETTORE */
        // Trovare posizione parola[a] in rotore iniziale //
        for(x=0;parola[a] != iniziale[x];x++);

        // Rotore destro //
        parola[a] = r_destro[x][1]; // Salvataggio parola[a] = alla posizione specchio del rotore iniziale //
        for(x=0;parola[a] != r_destro[x][0];x++);

        // Rotore centro //
        parola[a] = r_centro[x][1]; // Salvataggio parola[a] = alla posizione specchio del rotore destro //
        for(x=0;parola[a] != r_centro[x][0];x++);

        // Rotore sinisitro //
        parola[a] = r_sinistro[x][1]; // Salvataggio parola[a] = alla posizione specchio del rotore centro //
        for(x=0;parola[a] != r_sinistro[x][0];x++);

        // riflettore //
        parola[a] = riflettore[x][1]; // Salvataggio parola[a] = alla posizione specchio del rotore sinistro //
        for(x=0;parola[a] != riflettore[x][0];x++);

        /* DA RIFLETTORE A INIZIALE */
        // Rotore sinisitro //
        parola[a] = r_sinistro [x][0]; // Salvataggio parola[a] = alla posizione specchio del rotore riflettore //
        for(x=0;parola[a] != r_sinistro[x][1];x++);

        // Rotore centro //
        parola[a] = r_centro[x][0]; // Salvataggio parola[a] = alla posizione specchio del sinistro //
        for(x=0;parola[a] != r_centro[x][1];x++);

        // Rotore destro //
        parola[a] = r_destro[x][0]; // Salvataggio parola[a] = alla posizione specchio del rotore centro //
        for(x=0;parola[a] != r_destro[x][1];x++);

        // Rotore iniziale //
        parola[a] = iniziale[x]; // Salvataggio parola[a] = alla posizione specchio del rotore destro //
        cout<< parola[a];

        /* CAMBIO POSIZIONE MATRICI */
            shift[0]= r_destro[0][0];
            shift[1]= r_destro[0][1];
            for(k=0; k<25; k++)
            {
                for(j=0; j<2; j++)
                {
                    r_destro[k][j]=r_destro[k+1][j];
                }
            }
            r_destro[25][0]=shift[0];
            r_destro[25][1]=shift[1];
            cont_rd++;

            if(cont_rd==15 && verifica == false)
            {
                shift[0]= r_centro[0][0];
                shift[1]= r_centro[0][1];
                for(k=0; k<25; k++)
                {
                    for(j=0; j<2; j++)
                    {
                        r_centro[k][j]=r_centro[k+1][j];
                    }
                }
                r_centro[25][0]=shift[0];
                r_centro[25][1]=shift[1];
                verifica=true;
                cont_rc++;
                cont_rd=0;
            }
            else if(cont_rd==26)
            {
                shift[0]= r_centro[0][0];
                shift[1]= r_centro[0][1];
                for(k=0; k<25; k++)
                {
                    for(j=0; j<2; j++)
                    {
                        r_centro[k][j]=r_centro[k+1][j];
                    }
                }
                r_centro[25][0]=shift[0];
                r_centro[25][1]=shift[1];
                cont_rd=0;
                cont_rc++;

            }
            else if(cont_rc==26)
            {
                shift[0]= r_sinistro[0][0];
                shift[1]= r_sinistro[0][1];
                for(k=0; k<25; k++)
                {
                    for(j=0; j<2; j++)
                    {
                        r_sinistro[k][j]=r_sinistro[k+1][j];
                    }
                }
                r_sinistro[25][0]=shift[0];
                r_sinistro[25][1]=shift[1];
                cont_rd=0;
                cont_rc=0;
            };
        a++;
    }while(length_parola-1>=a);
}