JE

#include <iostream>
#include <fstream>
#include <time.h>
#include <stdlib.h>
#include <string>

using namespace std;

int wczytaj_i(string tekst)
{
    int a;
    cout<<tekst;
    cin>>a;
    return a;
}

string wczytaj_s(string tekst)
{
    string a;
    cout<<tekst;
    cin>>a;
    return a;
}

bool utworz_rotor(string sciezka_dostepu)
{
    srand(time(NULL));
    int pozostale=0;
    //Tworzy tablicę sprawdzającą czy dana liczba się powtórzyła (0 - brak wystąpienia, 1 - liczba jest już zapisana do pliku)
    bool tablicawartosci[256];
    for (int i=0; i<256; i++)
      tablicawartosci[i]=false;
    //Otwarcie pliku, jeśli się nie uda funkcja zwraca błąd
    fstream plik;
    plik.open (sciezka_dostepu.c_str(), ios::out);
    if (!plik.good())
      return false;
    unsigned char litera;
    //Losowanie liter bez powtórzeń, za każdym razem gdy litera się powtórzy to jest zwiększana o jeden dopóki nie trafi na literę która nie wystąpiła.
    for (int i=0; i<256; i++)
    {
        litera = rand()%256;
        while(tablicawartosci[litera])
        {
            if (litera<255)
                litera++;
            else
                litera=0;
        }
        tablicawartosci[litera]=true;
        plik<<(int)litera<<"\n";
    }
    plik.close();
    return true;
}

unsigned char rotor(unsigned char znak, int pozycja_rotora, unsigned char danerotora[])
{
    pozycja_rotora=znak+pozycja_rotora;
    if (!(pozycja_rotora<256))
        znak=pozycja_rotora-256;
    else
        znak=pozycja_rotora;
    unsigned char tmp=danerotora[znak];
    return tmp;
}

unsigned char rotor_deszyfr(unsigned char znak, int pozycja_rotora, unsigned char danerotora[])
{
    int i;
    for (i=0; i<256; i++)
    {
        if (danerotora[i]==znak)
            break;
    }
    pozycja_rotora=i-pozycja_rotora;
    if (!(pozycja_rotora>0))
        i=pozycja_rotora-256;
    else
        i=pozycja_rotora;
    unsigned char tmp=i;
    return tmp;
}

unsigned char lustro(unsigned char znak)
{
    return 255-(int)znak;
}

int szyfrowanie_enigma(unsigned char rotor1[], unsigned char rotor2[], string nazwaplikuszyfr, string nazwaplikuwynik, bool szyfr)
{
    fstream plikszyfr;
    plikszyfr.open(nazwaplikuszyfr.c_str(), ios::in);
    if (!plikszyfr.good())
        return 1;
    fstream plikwynik;
    plikwynik.open(nazwaplikuwynik.c_str(), ios::out);
    if (!plikwynik.good())
        return 2;

    unsigned char znak=0;
    int i=0;
    int j=0;
    while (!plikszyfr.eof())
    {
        char test;
        plikszyfr.get(test);
        znak=test;
        if (szyfr)
        {
            znak=rotor(znak, i, rotor1);
            znak=rotor(znak, j, rotor2);
        }
        else
        {
            znak=rotor_deszyfr(znak, j, rotor2);
            znak=rotor_deszyfr(znak, i, rotor1);
        }
        plikwynik<<znak;
        if (i<256)
            i++;
        else
        {
            i=0;
            j++;
        }
        if (!(j<256))
            j=0;
    }
    plikszyfr.close();
    plikwynik.close();
    return 0;
}

 //Sprawdzenie czy rotor istnieje, jeśli nie zostaje automatycznie wygenerowany z podaną nazwą. Jeśli funkcja zwróci fałsz oznacz że wystąpił błąd podczas tworzenia rotora.
bool rotor_exists(string sciezka_dostepu)
{
    fstream plik;
    plik.open(sciezka_dostepu.c_str(), ios::in);
    if (!plik.good())
    {
        plik.close();
        cout<<"Brak rotora o nazwie "<<sciezka_dostepu<<". Rotor ten zostanie utworzony!"<<endl;
        if (utworz_rotor(sciezka_dostepu))
        {
            cout<<"Rotor "<<sciezka_dostepu<<" zostal pomyslnie utworzony!"<<endl;
            return true;
        }
        else
        {
            cout<<"Wystapil blad w tworzeniu "<<sciezka_dostepu<<". Program zostanie zamkniety!"<<endl;
            return false;
        }
    }
    else
    {
        plik.close();
        return true;
    }
}

void rotor_wczytaj(unsigned char tablica[], string sciezka_dostepu)
{
    fstream plik;
    plik.open(sciezka_dostepu.c_str(), ios::in);
    for (int i=0; i<256; i++)
    {
        string dane;
        getline(plik, dane);
        tablica[i]=stoi(dane);
    }
    plik.close();
}

int main()
{
    //Wczytanie ustawień rotora.
    string nazwarotora1=wczytaj_s("Podaj sciezke dla pierwszego rotora: ");
    string nazwarotora2=wczytaj_s("Podaj sciezke dla drugiego rotora: ");
    //Sprawdzenie czy rotor istnieje, jeśli nie zostaje automatycznie wygenerowany z podaną nazwą. Jeśli program zwróci 1 lub 2 odpowiada to błędowi przy tworzeniu rotora kolejno pierwszego lub drugiego.
    if (!rotor_exists(nazwarotora1))
        return 1;
    if (!rotor_exists(nazwarotora2))
        return 2;

    unsigned char rotor1[256];
    unsigned char rotor2[256];

    rotor_wczytaj(rotor1, nazwarotora1);
    rotor_wczytaj(rotor2, nazwarotora2);

    int decyzja=wczytaj_i("Wybierz opcje:\n1.Szyfruj plik\n2.Rozszyfruj plik");
    string nazwaplikuszyfr=wczytaj_s("Podaj nazwe pliku ktory chcesz zaszyfrowac (z rozszerzeniem): ");
    string nazwaplikuwynik=wczytaj_s("Podaj nazwe pliku w ktorym zapisac wynik (program nie narzuca rozszerzenia) :");
    if (decyzja==1)
        int a=szyfrowanie_enigma(rotor1, rotor2, nazwaplikuszyfr, nazwaplikuwynik, true);
    if (decyzja==2)
        int a=szyfrowanie_enigma(rotor1, rotor2, nazwaplikuszyfr, nazwaplikuwynik, false);

    return 0;
}