Przejdź do treści

Szyfr Cezara w C i C++

Kompletny program, który skompilujesz od razu. Skopiuj go albo wpisz własny tekst i zobacz, co kod robi z każdą literą.

caesar.c
#include <stdio.h> void caesar(const char *text, int shift, char *result) {    int i;    for (i = 0; text[i] != '\0'; i++) {        char c = text[i];        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {            char base = (c <= 'Z') ? 'A' : 'a';            int index = ((c - base + shift) % 26 + 26) % 26;            result[i] = base + index;        } else {            result[i] = c;        }    }    result[i] = '\0';} int main(void) {    char result[100];    caesar("Witaj świecie!", 3, result);    printf("%s\n", result);    // Zlwdm śzlhflh!    return 0;}
reklama

Kompilacja i uruchomienie

Zapisz program jako caesar.c i skompiluj go przez gcc lub clang. W Windows drugie polecenie to caesar.exe.

Terminal
gcc caesar.c -o caesar./caesar

Program wypisze zaszyfrowany tekst. Jeśli sam szyfr jest dla ciebie nowy, zajrzyj do przewodnika, w którym nie ma kodu.

Jak działa ten kod

char w C to mała liczba, więc można na nim liczyć: 'W' - 'A' daje 22, czyli miejsce litery w alfabecie. Po dodaniu przesunięcia modulo utrzymuje wynik między 0 a 25, dlatego przy przesunięciu 3 litera Z trafia na C. base + index zamienia liczbę z powrotem na literę.

Funkcja w C nie zwróci napisu tak jak w Pythonie czy Javie, więc wywołujący przekazuje result, czyli bufor do zapisu. Musi on pomieścić tekst i jeszcze jeden bajt, bo ostatnia linia funkcji dopisuje '\0', którym kończy się każdy napis w C.

Spacje, interpunkcja i cyfry idą gałęzią else i są kopiowane bez zmian. Tak samo polskie litery: w UTF-8 „ś” to dwa bajty spoza zakresów A–Z, więc oba trafiają do wyniku takie, jakie były.

Deszyfrowanie w C

Druga funkcja nie jest potrzebna. Odszyfrowanie to takie samo przesunięcie w drugą stronę, więc w main wystarczy podać liczbę ujemną:

C
caesar("Zlwdm śzlhflh!", -3, result);printf("%s\n", result);// Witaj świecie!

Stąd ten dziwny wzór. W C operator % zachowuje znak lewej liczby, więc -3 % 26 to -3, a takiej pozycji litery nie ma. Po dodaniu 26 i ponownym modulo wychodzi 23, czyli A wraca na X. W wersji w Pythonie robi to za ciebie sam operator %.

Wczytywanie tekstu z klawiatury

Jeśli zadanie wymaga danych z klawiatury, zastąp main tą wersją. fgets czyta całą linię razem ze spacjami i nigdy nie zapisze więcej, niż pozwala podany rozmiar, czego nie gwarantuje scanf("%s").

C
#include <string.h> int main(void) {    char text[100], result[100];    int shift;     printf("Tekst: ");    fgets(text, sizeof text, stdin);    text[strcspn(text, "\n")] = '\0';     printf("Przesunięcie: ");    scanf("%d", &shift);     caesar(text, shift, result);    printf("%s\n", result);    return 0;}

fgets zostawia w napisie znak Enter. Linijka ze strcspn go usuwa i działa też przy pustej linii.

Klucz z wiersza poleceń

Czasem program ma dostać dane jako argumenty uruchomienia. Tutaj przesunięcie i tekst pochodzą z argv:

C
#include <stdlib.h>#include <string.h> int main(int argc, char *argv[]) {    if (argc != 3) {        printf("Użycie: %s <przesunięcie> <tekst>\n", argv[0]);        return 1;    }     char result[strlen(argv[2]) + 1];    caesar(argv[2], atoi(argv[1]), result);    printf("%s\n", result);    return 0;} // ./caesar 3 "Witaj świecie!"// Zlwdm śzlhflh!

argv[1] to wciąż tekst, dlatego atoi zamienia go na liczbę. Rozmiar bufora wynika z długości danych, więc długi argument go nie przepełni.

Łamanie szyfru metodą brute force

Przy 26 literach do sprawdzenia jest tylko 25 przesunięć, więc krótka pętla odczyta wiadomość bez klucza. Wystarczy znaleźć w wynikach linijkę, która ma sens:

C
void crack(const char *text) {    char result[100];    for (int shift = 1; shift < 26; shift++) {        caesar(text, -shift, result);        printf("%d %s\n", shift, result);    }} int main(void) {    crack("Zlwdm śzlhflh!");    // 1 Ykvcl śykgekg!    // 2 Xjubk śxjfdjf!    // 3 Witaj świecie!    // ...    return 0;}

Więcej o tej metodzie przeczytasz w artykule o ataku brute force, a łamacz online zrobi to samo w przeglądarce.

Cyfry i polskie znaki

Żeby przesuwać coś więcej niż A–Z, zapisz znaki w napisie i szukaj każdego przez strchr. Ta wersja przesuwa też cyfry. unsigned char jest tu ważny, bo przekazanie ujemnego char do tolower czy isupper to niezdefiniowane zachowanie.

C
#include <ctype.h>#include <string.h> void caesar_alphabet(const char *text, int shift, char *result) {    const char *alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";    int size = strlen(alphabet);    int i;    for (i = 0; text[i] != '\0'; i++) {        unsigned char c = text[i];        const char *found = strchr(alphabet, tolower(c));        if (found == NULL) {            result[i] = c;        } else {            int index = ((found - alphabet + shift) % size + size) % size;            result[i] = isupper(c) ? toupper(alphabet[index]) : alphabet[index];        }    }    result[i] = '\0';} int main(void) {    char result[100];    caesar_alphabet("Sala 101", 3, result);    printf("%s\n", result);    // Vdod 434    return 0;}

To działa tylko dla znaków mieszczących się w jednym bajcie. Polskie litery zajmują w UTF-8 dwa bajty, więc potrzebny byłby wchar_t i ustawienia lokalizacji, które różnią się między systemami. Jeśli ich potrzebujesz, dużo prościej jest w wersji w Pythonie, a narzędzie szyfru Cezara ma gotowy polski alfabet.

Szyfrowanie pliku tekstowego

Czytaj plik linia po linii i każdy wynik zapisuj do nowego pliku. Zawsze sprawdzaj fopen, bo gdy pliku nie da się otworzyć, zwraca NULL.

C
int main(void) {    char line[1000], result[1000];    FILE *in = fopen("message.txt", "r");    FILE *out = fopen("encrypted.txt", "w");     if (in == NULL || out == NULL) {        perror("fopen");        return 1;    }     while (fgets(line, sizeof line, in) != NULL) {        caesar(line, 3, result);        fputs(result, out);    }     fclose(in);    fclose(out);    return 0;}

Testowanie kodu

Napisy porównuj przez strcmp, bo == porównuje tylko ich adresy. Niespełniony assert zatrzyma program i wskaże linię. Jeśli wszystko gra, program wypisze OK.

C
#include <assert.h>#include <string.h> int main(void) {    char r[100];    caesar("ABC", 3, r);    assert(strcmp(r, "DEF") == 0);    caesar("xyz", 3, r);    assert(strcmp(r, "abc") == 0);    caesar("Hello, World!", 5, r);    assert(strcmp(r, "Mjqqt, Btwqi!") == 0);    caesar("A", -27, r);    assert(strcmp(r, "Z") == 0);    caesar("é", 3, r);    assert(strcmp(r, "é") == 0);    printf("OK\n");    return 0;}

Szyfr Cezara w C++

W C++ std::string sam zarządza pamięcią, więc funkcja może po prostu zwrócić wynik i nie trzeba liczyć rozmiaru bufora. Arytmetyka jest ta sama, podobnie jak dodatkowy krok dla liczb ujemnych, bo % działa w C++ tak jak w C.

C++
#include <iostream>#include <string> std::string caesar(std::string text, int shift) {    for (char &c : text) {        if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {            char base = (c <= 'Z') ? 'A' : 'a';            c = base + ((c - base + shift) % 26 + 26) % 26;        }    }    return text;} int main() {    std::cout << caesar("Witaj świecie!", 3) << "\n";    // Zlwdm śzlhflh!}

Najczęstsze błędy

Klasyczny błąd to brak '\0', przez co printf czyta dalej, poza koniec tekstu. Niewiele rzadszy jest bufor krótszy o jeden bajt. Usuwanie znaku nowej linii przez text[strlen(text) - 1] też bywa groźne, bo przy pustym napisie odczytuje pamięć przed jego początkiem. A bez dodatkowego + 26 deszyfrowanie daje symbole zamiast liter.

Najczęstsze pytania

Jakiego kompilatora i standardu C potrzebuję?

Wystarczy dowolny kompilator obsługujący C99, na przykład gcc lub clang. Kod z tej strony skompilowaliśmy w clang w trybie C99, a wersję C++ jako C++17, bez ostrzeżeń.

Czy mogę tym chronić prawdziwe dane?

Nie. Pętla pokazana wyżej łamie ten szyfr w kilka sekund. Używaj go do nauki i łamigłówek, a prawdziwe dane chroń utrzymywaną biblioteką, na przykład libsodium.

Jak sprawdzić, czy wynik jest poprawny?

Wpisz ten sam tekst i przesunięcie w narzędziu szyfru Cezara i porównaj. Ze swoich testów możesz też wywołać darmowe REST API.

Co dalej