Jak napisać program szyfrujący pliki szyfrem gaderypoluki?

Na wstępie tylko nadmienię, że jestem na studiach informatycznych, przerobiliśmy tylko if, for, tablice i switch.

Dostaliśmy polecenie projektu do wykonania.

Napisz program, który koduje plik przy użyciu szyfru gaderypoluki. Szyfr powinien pozwalać na użycie co najmniej 3 słow-kluczy, które mają być wybierane przez switch -t. Program powinien być uruchamiany z konsoli z danymi parametrami: program.exe -i input.txt -o output.txt -t 1.

Całość ma być napisana w C. Nie mam bladego pojęcia czym są te parametry, nie wiem jak przeprowadzać operacje na pikach oraz jak ogólnie miałby wyglądać taki kod.
Wiem, że wygląda to jakbym prosił o gotowe zadanie ale po prostu w tym poleceniu jest strasznie dużo rzeczy, których nie wiem a sytuacja nie rozjaśnia się po czytaniu różnych poradniczków i innych tego typu rzeczy w internecie.

Chciałbym przynajmniej wiedzieć jak się za to zabrać. Proszę o pomoc.

przerobiliśmy tylko if, for, tablice i switch.

W takim razie nie chce mi się wierzyć, że:

Dostaliśmy polecenie projektu do wykonania.
"Napisz program, który koduje plik przy użyciu szyfru gaderypoluki. Szyfr powinien pozwalać na użycie co najmniej 3 słow-kluczy, które mają być wybierane przez switch -t. Program powinien być uruchamiany z konsoli z danymi parametrami: program.exe -i input.txt -o output.txt -t 1."

kmph napisał(a):

przerobiliśmy tylko if, for, tablice i switch.

W takim razie nie chce mi się wierzyć, że:

Dostaliśmy polecenie projektu do wykonania.
"Napisz program, który koduje plik przy użyciu szyfru gaderypoluki. Szyfr powinien pozwalać na użycie co najmniej 3 słow-kluczy, które mają być wybierane przez switch -t. Program powinien być uruchamiany z konsoli z danymi parametrami: program.exe -i input.txt -o output.txt -t 1."

Gdyby tak nie było to bym tu nie pisał.

Właśnie napisałem ten program za Ciebie, ale oczywiście nie wyślę go, bo to byłoby danie ryby, zamiast wędki. W zamian za to dam parę wskazówek.

Zdefiniuj sobie tablicę kluczy. Później zrób pętlę w której przejdziesz po wszystkich argumentach programu (→ poczytaj o argc i argv w C).
Jeśli napotkasz na "-t", "-i" lub "-o" (→ porównaj argument używając strcmp), to odczytaj argument o indeksie i + 1. W zależności od tego co to jest:

1/ Jeśli to nr klucza, zapisz go jako unsigned int w pewnej zmiennej.
2/ Jeśli to -i, otwórz plik do odczytu (→ fopen) o odpowiedniej nazwie.
3/ jeśli to -o, otwórz plik do zapisu (→ fopen) o odpowiedniej nazwie.

Później wybierz odpowiedni klucz z tablicy kluczy.

Jeśli otwarto obydwa pliki, to wczytaj linia po linii plik do odczytu przez → fgets.
W pętli przejdź po wszystkich znakach. Dla każdego znaku:
1/ przejdź po literkach klucza, iterując co dwa znaki.
2/ Zapisz do zmiennej first znak o parzystym indeksie oraz second → znak o nieparzystym indeksie.
3/ jeśli literka z pliku do odczytu jest równa first, zapisz do pliku second (jeśli second, zapisz first).
4/ jeśli nie udało się znaleźć literki z pliku do odczytu w wybranym kluczu, zapisz literkę z pliku do odczytu bez zmian

Zamknij wszystkie otwarte pliki.

Dla ułatwienia wrzucam mój program z liniami w losowej kolejności (rozsypanka). Może uda Ci się ułożyć z tego program w dobrej kolejności:

which = 1;
                        fprintf(output_file, "%c", second);
            case '2':
            case '0':
#include <stdio.h>
        "KACEMINUTOWY"
                    char first = key[key_idx];
        char line[1024] = {0};
            i++;
            i++;
            i++;
                    char second = key[key_idx + 1];
            }
            }
                    else if(second == current_char) {
    if(output_file != NULL) {
                if(!substituted) {
                break;
                break;
                break;
                which = 0;
}
            input_file = fopen(argv[i + 1], "r");
        fclose(output_file);
                char current_char = line[idx];
        if(strcmp(argv[i], "-t") == 0 && i < argc - 1) {
                which = 2;
            for(unsigned idx = 0; idx < 1024 && line[idx] != '\0'; ++idx) {
        while(fgets(line, 1024, input_file) != NULL) {
                    fprintf(output_file, "%c", current_char);
    if(input_file != NULL && output_file != NULL) {
        }
        }
        }
        }
#include <stdbool.h>
                }
                }
                for(unsigned key_idx = 0; key_idx < strlen(key) && !substituted; key_idx += 2) {
    }
    }
    }
    }
                bool substituted = false;
    };
        "GADERYPOLUKI",
            output_file = fopen(argv[i + 1], "w");
            default:
    const char *keys[] = {
#include <string.h>
                        substituted = true;
                        substituted = true;
                    if(first == current_char) {
        else if(strcmp(argv[i], "-i") == 0 && i < argc - 1) {
    for(unsigned i = 1; i < argc; ++i) {
int main(int argc, char *argv[])
    if(input_file != NULL) {
    FILE *input_file = NULL, *output_file = NULL;
        else if(strcmp(argv[i], "-o") == 0 && i < argc - 1) {
                return 1;
    const char *key = keys[which];
    return 0;
                printf("Nie znam takiego klucza!\n");
        "POLITYKARENU",
        fclose(input_file);
{
            which = argv[i + 1][0];
            switch(argv[i + 1][0]) {
            case '1':
    unsigned which = 0;
                    }
                    }
                        fprintf(output_file, "%c", first);```

Sam szyfr jest prosty i do zrobienia z takim zasobem umiejętności, ale żeby od kogoś uczonego programowania od podstaw wymagać używania parametrów konsoli i otwierania plików bez wyjaśnienia tego? Nie wiem, może nie nadążam za trybem edukacji.

No dobrze, na szybko:

Otwieranie pliku do czytania:

FILE *plik_wejsciowy = fopen("nazwa_pliku", "r");

Czytanie z tego pliku:

char ch;
fscanf(plik_wejsciowy, "%c", &ch)

Czyli dokładnie tak, jak czytasz z konsoli, tylko zamiast scanf(format, zmienne) piszesz fscanf(plik, format, zmienne)

Uwaga: fscanf (jak i scanf) zwraca za każdym razem , do ilu zmiennych udało mu się zapisać. Jeśli plik się skończy, no to fscanf zwróci, że nie udało mu się zapisać (czyli zwróci EOF) Dlatego czytanie z pliku znak po znaku:

while(fscanf(plik_wejsciowy, "%c",& ch) == 1) {
  //kod
}

Lub:

while(fscanf(plik_wejsciowy, "%c", &ch) != EOF) {
   //kod
}

Pomijam to ew. problem gdy plik jest w nieodpowiednim formacie (np. chcesz liczbę a masz alsdkjf;slkdj). Gdyż ten problem nie ma tu chyba znaczenia.

Otwieranie pliku do pisania:

FILE *plik_wyjsciowy = fopen("nazwa_pliku", "w");

Pisanie do tego pliku:

char ch = 'a';
fprintf(plik_wyjsciowy, "%c", ch);

Szyfr Gaderypoluki:

https://pl.wikipedia.org/wiki/Gaderypoluki

Argumenty konsoli:

Zamiast:

int main()
{

}

Piszesz:

int main(int argc, char* argv[])
{

}

argc - liczba przekazanych parametrów, licząc nazwę pliku.

argv - tablica stringów zawierająca parametry. Przy czym argv[0] zawsze zawiera nazwę pliku z programem. argv[1] do argv[argc-1] włącznie to są parametry.

Np przy przykładowym wywołaniu program.exe -i input.txt -o output.txt -t 1 będzie:

argc będzie równe 7
argv będzie zawierało: ["program.exe", "-i", "input.txt", "-o", "output.txt", "-t", "1"]

A więc masz tu stringa "1". Przerzucić go do liczby możesz tak:

char str[] = "1";
int i = atoi(str);

Zapomniałem jednego:

Zamykanie pliku:

fclose(plik);

Czyli np.:

FILE *plik = fopen("bla.txt", "w");
/// piszemy do pliku
fclose(plik);

Aha, i zakładam też, że plik wejściowy i wyjściowy są różne. Jeśli są te same, to robi się bardziej skomplikowanie.