3. Caesar cipher oop

Caesar cipher oop

  • P

    danke fuer deine Antwort.
    Der Debugger läuft schon ne weile.
    Leider auf keinen grünen Zweig gekommen.

    0
  • Administrator

    pampy schrieb:

    Der Debugger läuft schon ne weile.

    Du weisst schon was ein Debugger ist? Das man mit dem Debugger ein Code Schritt für Schritt zur Laufzeit analysieren kann? Und das man nach jedem Schritt den aktuellen Wert der Variablen auslesen kann?
    Gerade um Algorithmen zu analysieren und Fehler darin zu finden, ist ein Debugger das absolut beste Mittel.

    Grüssli

    0

  • ich weiß das dass nicht hilft und unangebracht ist...
    Ich habe auch schon einen (verbesserten sogar) Ceasar Algorithmus geschrieben.
    (es heißt so Monoalphabetische Substitotion), aber ich poste mal den Download.

    es ist zwar etwas unelegant und unübersichtlich, aber es funktioniert und könnte dir ja helfen es selbst zu schreiben:

    encoder only 1.1.exe 	508.68 KB 	http://ul.to/649fx9
keycreator 1.1.exe 	516.66 KB 	http://ul.to/fwoiyp
decoder 1.0.exe 	520.64 KB 	http://ul.to/uiy0tr

    HIER !!!

    0
  • T

    Sorry, aber was soll er bitte mit dem kompilierten Executables anfangen? Wie die Cäsar-Verschlüsselung funktioniert wird er entweder wissen, oder es leicht auf Wikipedia nachlesen können.

    Da ist Reverse-Engineering deiner Programme einfach nur unnötig.

    0
  • F
     

    #include <iostream>

class Caesar
{
    private:
        int offset;
    public:
        Caesar() {offset = 3;}
        std::string decode (const std::string &text);
        std::string encode (const std::string &text);
};

std::string Caesar::encode(const std::string &text)
{
    std::string temptext = text;
    int tempascii;
    std::transform(temptext.begin(), temptext.end(), temptext.begin(), toupper);
    for(int i = 0; i < temptext.length(); i++)
    {
        int tempascii = static_cast<int>(temptext[i]) + offset;
        if(tempascii > 90)
        {
            tempascii = 65 + (tempascii - 91);
        }
        temptext[i] = static_cast<char>(tempascii);
    }
    return temptext;
}

std::string Caesar::decode(const std::string &text)
{
    std::string temptext = text;
    int tempascii;
    std::transform(temptext.begin(), temptext.end(), temptext.begin(), toupper);
    for(int i = 0; i < temptext.length(); i++)
    {
        int tempascii = static_cast<int>(temptext[i]) - offset;
        if(tempascii < 65)
        {
            tempascii = 90 + (tempascii - 64);
        }
        temptext[i] = static_cast<char>(tempascii);
    }
    return temptext;
}

int main ()
{
    Caesar cipher;
    std::string abc;
    std::cout << "Hallo Caesar!" << std::endl;
    std::cout << "Wie lautet deine Nachricht: " ;
    std::cin >>abc ;
    std::cout << "codiert  " << cipher.encode(abc) << std::endl;
    std::cout << "decodiert    " << cipher.decode(abc) << std::endl;
    std::cin.get();
    system ("pause");
    return 0;
}

    Da du schon eine Klasse benutzt, rate ich dir auch zu 2 Methoden.

    0
  • V
     

    static_cast<int>(temptext[i])

    ???

    tempascii = 65 + (tempascii - 91);

    ?????

    warum nicht inplace ver- und entschlüsseln?

    std::string Caesar::decode(const std::string &text,int key)
{
    return encode(text,-key);
}
    0

  • UUUOOPPPSSS hab ich vergessen ^^

    0
  • F

    Er will das Caesarverschlüsselungsverfahren benutzen. Also müssen erstmal ALLE Buchstaben groß gesetzt werden.

    pampy schrieb:

    c = (c - 'A' +26 + off) % 26 + 'Ä';

    Versteh ich nicht, wieso + Ä ? Wenn c == 'C' ist, wäre c laut der ASCII Tabelle 67, A = 65, Ä = 196 und off wäre beim encoden -3.

    (67 - 65 + 26 + -3) % 26 + 196 = 221

    (67 - 65 + 26 + -3) = 25 da kann man nicht % 26 machen, da es kein Rest geben wird.

    Übergebe ich den String nun nochmal und benutze die Decodierung, wird also 221 genutzt. Gleiche Rechung nur mit +3 statt -3. Somit wird dann 224 zurückgegeben, kein gültiger Buchstabe.

    pampy schrieb:

    else if(c >= 'a' && c <= 'z')
            text[i] = c;

    Also wenn ich den String übergebe "dzafwef", wird beim ersten Durchlauf der for-Schleife das d genommen. d ist zwischen a und z, wird angenommen. text[0] = "d". Durch text[i] = c, c entspricht im ersten Durchlauf "d", wird text[0] einfach wieder auf d gesetzt? Bei einem String von nur kleinen Buchstaben wird der String also nicht verändert.

    Selbst wenn deine Formel stimmen würde, solltest du wissen, dass Caesar nicht solche ASCII Zeichen wie unser Computer hatte. Also wenn du Y nimmst und um 3 Stellen verändern willst, gehst du über Z (1 Stelle verbraucht), musst dann wieder zu A und dann zu B.

    Hatte ich nun irgendwas falsch zu bemängeln oder gar falsch gesagt, wird doch bitte konstruktive Kritik geschrieben 😉

    0
  • P

    habs hinbekommen, danke fuer eure Antworten!

    Super Forum 👍

    0
  • U

    Also manchmal ist OOP-Fanatismus Nonsens, dies ist ein perfektes Beispiel dafür.

    So gehts viel leichter, schlanker und schneller:

    #include <stdio.h>
#include <string.h>

inline char rot13 (char c)
{ return (~c - 1 / (~((c = ~c) | 32) / 13 * 2 - 11) * 13); } 

int main (void)
{
    char buffer[] = "hallo, caeser rocks!";
    size_t length = strlen (buffer);

    // orginal
    printf ("orginal: %s\n", buffer);

    // encodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("encoded: %s\n", buffer);

    // decodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("decoded: %s\n", buffer);
}
    0
  • ?

    unsigned long schrieb:

    Also manchmal ist OOP-Fanatismus Nonsens, dies ist ein perfektes Beispiel dafür.

    So gehts viel leichter, schlanker und schneller:

    #include <stdio.h>
#include <string.h>

inline char rot13 (char c)
{ return (~c - 1 / (~((c = ~c) | 32) / 13 * 2 - 11) * 13); } 

int main (void)
{
    char buffer[] = "hallo, caeser rocks!";
    size_t length = strlen (buffer);

    // orginal
    printf ("orginal: %s\n", buffer);

    // encodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("encoded: %s\n", buffer);

    // decodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("decoded: %s\n", buffer);
}

    Sind dir die Newlines ausgegangen? Hier hast du zwei:
    0
  • ?

    Großzügiger Spender schrieb:

    unsigned long schrieb:

    Also manchmal ist OOP-Fanatismus Nonsens, dies ist ein perfektes Beispiel dafür.

    So gehts viel leichter, schlanker und schneller:

    #include <stdio.h>
#include <string.h>

inline char rot13 (char c)
{ return (~c - 1 / (~((c = ~c) | 32) / 13 * 2 - 11) * 13); } 

int main (void)
{
    char buffer[] = "hallo, caeser rocks!";
    size_t length = strlen (buffer);

    // orginal
    printf ("orginal: %s\n", buffer);

    // encodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("encoded: %s\n", buffer);

    // decodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("decoded: %s\n", buffer);
}

    Sind dir die Newlines ausgegangen? Hier hast du zwei:

    Args Marc++us hat sie geklaut. Hier hast du ein Programm, dass dir bei jedem Aufruf zwei erzeugt, aber verrat es keinem!

    #include <iostream>

int main()
{
   std::cout << "\n\n";
}
    0
  • ?

    @Großzügiger Spender:
    auto equals banane?

    0
  • ?

    unsigned long schrieb:

    Also manchmal ist OOP-Fanatismus Nonsens, dies ist ein perfektes Beispiel dafür.

    So gehts viel leichter, schlanker und schneller:

    #include <stdio.h>
#include <string.h>

inline char rot13 (char c)
{ return (~c - 1 / (~((c = ~c) | 32) / 13 * 2 - 11) * 13); } 

int main (void)
{
    char buffer[] = "hallo, caeser rocks!";
    size_t length = strlen (buffer);

    // orginal
    printf ("orginal: %s\n", buffer);

    // encodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("encoded: %s\n", buffer);

    // decodieren
    for (size_t i = 0; i < length; buffer[i] = rot13 (buffer[i]), ++i);
    printf ("decoded: %s\n", buffer);
}

    hey mann!111 dat is kein c++ es hat keine classen!!111 java is besser.

    0
  • ?

    Nö F# ist besser 🙂

    0
  • S

    unsigned long schrieb:

    Also manchmal ist OOP-Fanatismus Nonsens, dies ist ein perfektes Beispiel dafür....

    Habe ich auch sofort gedacht ... schon die Überschrift ist ein Widerspruch in sich.

    Was kommt als nächstes: "Freie-Funktionen-Klasse"? 😉

    Mal im Ernst: Je nachdem, was geübt werden soll:
    a) Caesar-Chiffre => freie Funktion (wenn ich auch unsigned longs obfuscated code nicht als Beispiel nehmen würde)
    b) OOP => Andere Aufgabe.

    Gruß,

    Simon2.

    0
  • F

    unsigned long schrieb:

    Also manchmal ist OOP-Fanatismus Nonsens, dies ist ein perfektes Beispiel dafür.

    So gehts viel leichter, schlanker und schneller:

    #include <stdio.h>
#include <string.h>

inline char rot13 (char c)
{ return (~c - 1 / (~((c = ~c) | 32) / 13 * 2 - 11) * 13); } 

int main (void)
{
    char buffer[] = "hallo, caeser rocks!";
    size_t length = strlen (buffer);

    // orginal
    printf ("orginal: %s\n", buffer);

    // encodieren
    for (size_t j = 0; i < length; buffer[j] = rot13 (buffer[j]), ++j);
    printf ("encoded: %s\n", buffer);

    // decodieren
    for (size_t j = 0; i < length; buffer[j] = rot13 (buffer[j]), ++j);
    printf ("decoded: %s\n", buffer);
}

    Wow das Programm funktioniert richtig gut ...
    Ironie off
    Die codierung, sowie die decodierung geht überhaupt nicht! Es soll alles ins große geschrieben und wenn man Y um 3 Stellen nach rechts verschieben soll, muss B als Endergebnis rauskommen.
    Das macht dein Programm nicht. Hast du es etwa nicht getestet ?...

    0
  • U

    *hust*

    da oben steht "rot13" nicht "rot3". Der Code sollte nur ein Denkanstoß dafür sein, dass es auch ohne OOP sogar besser (schneller, schlanker - einfach besser) geht.

    Noch was in eigener Sache:

    Dazu solltest du es unterlassen verfälschten Code zu posten. Stichwort Zeile 16 und 20 in deinem Post und meinem Post. Mein Code geht, dein geposteter nicht, da du absichtlich "i" und "j" in beiden Zeilen verschoben hast. Daher ist es unterste Schublade hier mit "Ironie" anzutanzen.

    Also kusch, kusch, ab in die Ecke und schämen.

    0
  • Administrator

    @unsigned long,
    Du hast durchaus zum Teil recht, wenn du das ganze aber doch bitte noch in C++ machen würdest, dann sähe es noch ein wenig besser aus:

    #include <string>
#include <iostream>
#include <algorithm>

char rot13(char c)
{
	return (~c - 1 / (~((c = ~c) | 32) / 13 * 2 - 11) * 13);
}

int main()
{ 
	std::string buffer = "hallo, caeser rocks!";

	// originial
	std::cout << "Original: " << buffer << std::endl;

	// encoding
	std::transform(buffer.begin(), buffer.end(), buffer.begin(), &rot13);
	std::cout << "Encoded:  " << buffer << std::endl;

	// decoding 
	std::transform(buffer.begin(), buffer.end(), buffer.begin(), &rot13);
	std::cout << "Decoded:  " << buffer << std::endl;

	return 0;
}

    Wieso sage ich "zum Teil"? Wenn du mal den Code von pampy genauer angeschaut hättest, dann hättest du eine Offset Variable entdeckt. Daher muss hier ein Objekt eingeführt werden.

    Allerdings hätte ich es persönlich über einen Funktor gemacht, also sowas:

    // Code von oben, statt der rot13 Funktion, eher sowas:
struct Encoding
{
  int m_offset;

  Encoding(int offset)
    : m_offset(offset)
  {
  }

  char operator ()(char c)
  {
    // ... Kodierung hier hin ... //
  }
}

// In der main dann:
std::transform(buffer.begin(), buffer.end(), buffer.begin(), Encoding(13));

// ...

    Aber ich würde sowas schon eher als fortgeschrittene Programmierung ansehen. Einem Anfänger traue ich jedenfalls so ein Vorgehen nicht einfach so zu. Schon nur wegen der Operatorüberladung.

    Grüssli

    0
  • S

    Dravere schrieb:

    ...Daher muss hier ein Objekt eingeführt werden....

    Naja ... aber nur, wenn man das (schicke und sprechende) transform() nutzen will.
    Mit einer simplen handkodierten Schleife hätte es eine einfache Funktion auch getan.

    Gruß,

    Simon2.

    0
Anmelden zum Antworten