Caesar cipher oop

[pampy]

Hallo!

//Caesar.cpp

#include "Caesar.h"
using namespace std;

string Caesar::code(string text, bool decode)
{
	int off = (decode)? -offset:offset;
	for (unsigned int i = 0; i < text.length(); i++)
	{
		unsigned char c = text[i];
		if (c >= 'A' && c <= 'Z')
			c = (c - 'A' +26 + off) % 26 + 'Ä';
		else if(c >= 'a' && c <= 'z')
			text[i] = c;	
	}
	return text;
}

//Caesar.h

#ifndef __Caesar__
#define __Caesar
#include <string>
class Caesar 
{
private:
	int offset;
	std::string code (std::string text, bool decode);
public:
	Caesar() {offset = 3;}
	void setOffset(int n){offset = n;}
	std::string decode (std::string text){return code (text, true);}
	std::string encode (std::string text){return code (text, false);}

};
#endif

main.cpp

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

Ausgabe

Hallo Caesar !
Wie lautet deine nachricht: aAa
decodiert  aAa
codiert  aAa

wo liegt der fehler?
danke!

[Dravere]

pampy schrieb:

wo liegt der fehler?

Gibt zwei Möglichkeiten:
1. Du zahlst uns zu wenig, damit wir den Fehler für dich finden.
2. Du verwendest keinen Debugger und suchst ihn selbst.

Ich würde die zweite Möglichkeit empfehlen. Es ist sowieso immer sehr gut, wenn man weiss, wie ein Debugger funktioniert.

Grüssli

[pampy]

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

[Dravere]

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

[5cript]

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 !!!

[The-Kenny]

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.

[freaky]

#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.

[volkard]

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);
}

[5cript]

UUUOOPPPSSS hab ich vergessen ^^

[freaky]

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

[pampy]

habs hinbekommen, danke fuer eure Antworten!

Super Forum

[unsigned long]

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);
}

[Großzügiger Spender]

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:

[Großzügiger Spender]

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";
}

[Großzügiger Spender Clone]

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

[lolwut]

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.

[Javerianer]

Nö F# ist besser

[Simon2]

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.

[freaky]

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 ?...

[unsigned long]

*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.