einfaches Bruteforce Prog mit fehler =C

[SeppJ]

Schreib dir nochmal sauber auf, wie dein Programm funktionieren soll. Falls das Programm alle Buchstabenkombinationen einer bestimmten Länge ausgeben soll, sehe ich nicht, wie du dir das bei diesem Code überhaupt vorstellst. Da werden wild die Werte von irgendwelchen Zählern verändert, ohne dass ein System erkennbar wäre.

Und setze unbedingt den Tipp mit der Benutzung von C++-Mitteln um. Du hast offensichtlich nicht viel Erfahrung im Umgang mit C-Strings, also warum nicht gleich das einfach benutzbare std::string nehmen? Das was du da derzeit mit den C-Strings treibst ist nämlich falsch und erzeugt undefiniertes Verhalten.

Und das Buch/Lehrwerk aus dem du die Begriffe math.h und string.h hast, ist hoffnungslos veraltet. Du solltest davon Abstand nehmen.

[1337shaddow]

Ok das programm soll so funktionieren:
1. Es fragt nach wieviele zeichen die wörter haben sollen
2. Es bildet alle möglichen Wörter aus den Zeichen a-z, A-Z, 1-0
Zum beispiel(3Buchstaben):
aaa
aab
aac
aad
...
aaz
aaA
...
aa0
aba
...

[SeppJ]

Jaaaa, das dachte ich mir schon.

Aber die Frage ist doch eher, wie du dir vorstellst, wie das funktionieren soll!

Gehen wir mal dein Programm einen Durchlauf mit Länge 2 durch und gucken, was passiert (und ignorieren dabei das undefinierte Verhalten, sondern tun das, was du dir gedacht hast):

[b]Anfang[/b]:
anzahl_zeichen = 2
aktuelles_wort: zwei chars, werte ungesetzt
counter = 0
counterII = 0
aktuelles_zeichen: ungesetzt

[b]while(counterII != pow(anzahl_zeichen, 62))[/b]
0 != 2 hoch 62. Schleife wird begonnen
 :warning: Hier das erste Mal undefiniertes Verhalten. Auf vielen Systemen ist 
2 hoch 62 > INT_MAX. Dies wird oftmals zu Endlosschleifen führen. :warning: 

[b]counterII++;[/b]
counterII = 1

[b]aktuelles_zeichen = anzahl_zeichen;[/b]
aktuelles_zeichen = 2

[b]counter++;[/b]
counter = 1

[b]if(counter == 63)[/b]
1 ungleich 63, if-Bedingung wird nicht ausgeführt

[b]aktuelles_wort[aktuelles_zeichen] = alle_zeichen[counter];[/b]
zweites zeichen von aktuelles Wort wird erstes Zeichen von alle_zeichen, also 
'a'.
 :warning: Undefiniertes Verhalten! Arrays beginnen bei 0! Es gibt kein 
aktuelles_wort[2], nur [0] und [1]. ebenso ist alle_zeichen[1] 'b' und nicht 
'a' :warning: 

[b]cout<< aktuelles_wort << endl;[/b]
aktuelles_wort wird ausgegeben. Dieses besteht aus einem ungesetzten Zeichen,
 gefolgt von einem 'a'-Zeichen.
 :warning: Wieder undefiniertes Verhalten! C-Strings funktionieren so einfach 
nicht! Ich will dir jetzt nicht den ganzen Umgang damit erklären, wenn 
std::string so nahe liegt, aber diese Aktion hier würde wild Werte aus dem 
Speicher auf die Standardausgabe schreiben. :warning: 

[b]
Nächste Runde[/b]
Die erste Rund hat ja schon nur Quatsch gemacht. Sie hätte "<undefiniert>a" 
ausgegeben wie du es gedacht hast, und sie gibt irgendwas total undefiniertes 
aus, weil du mit unnötig komplizierten Sachen hantierst, die du nicht 
verstehst. Ich glaube die nächste Iteration der Schleife kann ich mir sparen.

[1337shaddow]

Danke für den tipp ich habs en bissel verändert und es funktioniert fast perfekt!!!

#include <iostream>
#include <string.h>
#include <math.h>
#include <conio.h>
using namespace std;

int anzahl_zeichen, aktuelles_zeichen, counter = 0, counterIII=-1;
long double counterII;
//Buchstaben und Zahlen in einem Array speichern
char alle_zeichen[63] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

int main(){
    cout<<"Wieviele Zeichen soll das Wort haben?\n";
    cin>>anzahl_zeichen;
    char aktuelles_wort[anzahl_zeichen];
    while(counterIII!=anzahl_zeichen-1){
         counterIII++;
         aktuelles_wort[counterIII]='a';}
    while(counterII != pow(anzahl_zeichen, 62)){
          counterII++;
          aktuelles_zeichen = anzahl_zeichen-1;
          counter++;
          if(counter == 63){
                 aktuelles_zeichen--; 
                 while(aktuelles_wort[aktuelles_zeichen] == '0'){aktuelles_wort[aktuelles_zeichen] = 'a'; aktuelles_zeichen--;}
                 }//von der if(counter ==63)
          aktuelles_zeichen=anzahl_zeichen-1;
          aktuelles_wort[aktuelles_zeichen] = alle_zeichen[counter];
          cout<< aktuelles_wort << endl;
          getch();

    }//von der while(true)
    getch();
}//von der int main

wenn ich jetzt 2 eingeb, dann kommt erst aa, dann ab, ac, ad..., a9, a0, und dann kommt ganz oft a und ab und zu noch sonderzeichen, von denen ich gar nicht gewusst hab, dass es die gibt(Musiknoten, weiblichzeichen, smilie, Play-zeichen, ü in der Konsole!, ae, e mit zwei punkten drauf, usw. Das gleiche passiert wenn ich 3,4,5,6,.. eingeb.

[Gast]

Du kannst Dir das wir beim Zählen vorstellen:

000
001
002
003
...
999

Dasselbe willst Du mit Zeichen machen. Bei Zahlen ist der Zeichenvorrat [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]. Das gilt für jede Stelle. Wenn Du also für die niedrigste Stelle (im Beispiel oben ganz rechts), durch den Zeichenvorrat läufst und bei der '9' ankommst, ist das nächste Zeichen wieder die 0 und in der folgenden Stelle musst Du um eins im Zeichenvorrat weiter gehen.

Vielleicht helfen Dir die Überlegungen ja beim Realisieren des Algorithmus.

[SeppJ]

Wie gesagt: C-Strings und du hast keine Ahnung wie du damit umzugehen hast. Außerdem Überläufe. Vielleicht war ich etwas zu mild, als ich dich oben vor undefiniertem Verhalten gewarnt habe. Das klingt so harmlos. Es sind schwerwiegende Fehler! Alles was ich mit markiert hatte, ist grundlegend falsch. Die Arrayzählung scheinst du verbessert zu haben (habe ich jetzt aber nicht kontrolliert). Die anderen Sachen musst du dir unbedingt nochmal anschauen. Zum Beispiel könntest du die Abbruchbedingung der ersten Schleife so setzen, dass alle Buchstaben '0' sein müssen, damit das Programm endet.

Ob der verbesserte Algorithmus stimmt, mag ich jetzt nicht beurteilen, das bekommst du hoffentlich selber raus. es sieht unnötig kompliziert aus (ich würde es viel einfacher machen), aber das macht es ja nicht unbedingt falsch. Ein paar Kommentare dürften nicht schaden, dann kann man dir besser helfen.

[1337shaddow]

Wieder undefiniertes Verhalten! C-Strings funktionieren so einfach
nicht! Ich will dir jetzt nicht den ganzen Umgang damit erklären, wenn
std::string so nahe liegt, aber diese Aktion hier würde wild Werte aus dem
Speicher auf die Standardausgabe schreiben.

das hab ich net gepeilt. Was ist überhaupt str::string? und warum schreibt das wie wild werte aus dem Speicher?

Ich hab nochmal die abbruchsbedingung verändert

#include <iostream>
#include <string.h>
#include <conio.h>
using namespace std;

int anzahl_zeichen, aktuelles_zeichen, counter = 0, counterIII=-1;
bool abbruch = false;
//Buchstaben und Zahlen in einem Array speichern
char alle_zeichen[63] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

int main(){
    cout<<"Wieviele Zeichen soll das Wort haben?\n";
    cin>>anzahl_zeichen;
    char aktuelles_wort[anzahl_zeichen];
    while(counterIII!=anzahl_zeichen-1){
         counterIII++;
         aktuelles_wort[counterIII]='a';}
    while(abbruch == false){
          aktuelles_zeichen = anzahl_zeichen-1;
          counter++;
          if(counter == 63){
                 aktuelles_zeichen--; 
                 while(aktuelles_wort[aktuelles_zeichen] == '0' && aktuelles_zeichen >= 0){aktuelles_wort[aktuelles_zeichen] = 'a'; aktuelles_zeichen--;}
                 if(aktuelles_zeichen==0){abbruch=true;
                 }
                 }//von der if(counter ==63)
          aktuelles_wort[aktuelles_zeichen] = alle_zeichen[counter];
          cout<< aktuelles_wort << endl;
          getch();
    }//von der while(true)
    getch();
}//von der int main

Aso und Kommentare folgen noch

[SeppJ]

1337shaddow schrieb:

das hab ich net gepeilt. Was ist überhaupt str::string?

Google: std::string
http://www.cplusplus.com/reference/string/string/
http://en.wikipedia.org/wiki/String_(C%2B%2B)

und warum schreibt das wie wild werte aus dem Speicher?

http://en.wikipedia.org/wiki/C_string
http://en.wikipedia.org/wiki/C_string#Limitations

[1337shaddow]

ah danke das muss ich mir noch alles durchlesen.

Und ich hab den code jetzt mit Kommentaren versehen(und leicht verändert). hoffe das hilft.

#include <iostream>
#include <string.h>
#include <conio.h>
using namespace std;

int anzahl_zeichen, aktuelles_zeichen, counter = 0, counterIII=-1;
bool abbruch = false;
//Buchstaben und Zahlen in einem Array speichern
char alle_zeichen[63] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

int main(){
    //Liest ein wie viele zeichen das Wort aus der Brute-Force Attacke haben soll
    cout<<"Wieviele Zeichen soll das Wort haben?\n";
    cin>>anzahl_zeichen;
    //erstellt einen leeren String mit der anzahl an zeichen als Länge
    char aktuelles_wort[anzahl_zeichen];
    //Füllt das leere wort mit zeichen(immer "a")
    while(counterIII!=anzahl_zeichen-1){
         counterIII++;
         aktuelles_wort[counterIII]='a';}
    //Die Schleife, die die Wörter generiert und ausgibt, mit der Abbruchsbedingung, die bei bhjkfgsduf(unten) überprüft wird
    while(abbruch == false){
          //setzt den zähler, der die Position des Buchstaben angibt
          aktuelles_zeichen = anzahl_zeichen-1;
          //erhöht den counter, der den buchstaben bestimmt um eins höher
          counter++;
          //falls der counter mit der null fertig ist, wird als zeichen ein a gespeichert und das zeichen um eins zurückgesetzt
          //dann wird das so oft wiederholt, bis man beim ersten zeichen ankommt. Wenn das auch null ist wird die abbruchsbedingung erfüllt
          //und der Bool-schalter abbruch auf true gesetzt(bhjkfgsduf)
          if(counter == 63){
                 aktuelles_wort[aktuelles_zeichen] = 'a';
                 aktuelles_zeichen--; 
                 while(aktuelles_wort[aktuelles_zeichen] == '0' && aktuelles_zeichen >= 0){aktuelles_wort[aktuelles_zeichen] = 'a'; aktuelles_zeichen--;}
                 if(aktuelles_zeichen==0 && aktuelles_wort[aktuelles_zeichen] == '0'){abbruch=true;}//bhjkfgsduf
                 }//von der if(counter ==63)
          //dann wird das zeichen in dem Wort gespeichert und ausgegeben.
          aktuelles_wort[aktuelles_zeichen] = alle_zeichen[counter];
          cout<< aktuelles_wort << endl;
          getch();//nur zum testen. Wird wieder entfernt
    }//von der while(true)
    getch();
}//von der int main

[1337shaddow]

std::string bringt doch das gleiche, wie die andere variante, oder?
Weil ich hab des jetzt en bissel verändert, und dann kamen 1000 fehlermeldungen und ich hab des wieder verworfen.
aber so müssts doch auch gehen.

Aso ich hab noch nen Fehler entdeckt. Wenn man 1 eingibt, dann kommt:
a4D
b4D
c4D
...

und dann kommt nur noch komisches zeug. Ihr könnt den code ja mal compilen. Dann seht ihrs.

[SeppJ]

1337shaddow schrieb:

std::string bringt doch das gleiche, wie die andere variante, oder?

Nein. Unter anderem würde dies die folgenden Probleme lösen:
a) Deine Ausgabe ist total undefiniert, weil du überhaupt nicht auf die für C-Strings nötige Nullterminierung achtest.
b) Du bräuchtest dich beim Reservieren des Speichers für das aktuelle Wort nicht auf spezielle Features deines Compilers verlassen, sondern auf den C+=-Standard verlassen. Dadurch könntest du dein Programm dann auch mit jedem beliebigen Compiler übersetzen. Vermutlich ist es dir noch nicht einmal bewusst, aber char aktuelles_wort[anzahl_zeichen]; ist nicht durch den (aktuellen) Standard gedeckt.

Natürlich ist es nicht damit getan, einfach in der Definition char gegen std::string zu tauschen, ein bisschen Anpassung deines Programmes wäre schon noch nötig.

[SeppJ]

In meinem steten Streben nach unnötig komplizierten Antworten auf einfache Fragen, habe ich dieses Monstrum erschaffen:

#include <iostream>
#include <string>
#include <vector>
#include <cstddef>
#include <algorithm>

using namespace std;

class increasable_word
{
private:
  typedef std::vector<size_t> word_type;
  word_type word_as_number;
  string const alphabet;
public:
  increasable_word(size_t size, const string& alphabet): word_as_number(size), alphabet(alphabet) {}
  increasable_word operator++()
  {
    word_type::iterator i = word_as_number.begin();
   bool go_on;
    do
      {
        go_on=false;
        (*i)++;
        *i %= alphabet.size();
        if ((*i) == 0) {
          go_on=true;
          ++i;
        }
      }
    while (go_on  && (i != word_as_number.end()));
    return *this;
  }
  string as_string() const
  {
    string output (word_as_number.size(), 0);
    word_type::const_iterator i = word_as_number.begin();
    for (string::reverse_iterator j = output.rbegin(); j!=output.rend(); ++i, ++j)
      *j=alphabet[*i];
    return output;
  }
  bool maxed()
  {
    return (count(word_as_number.begin(), word_as_number.end(), alphabet.size()-1) == word_as_number.size());
  }
};

ostream& operator<<(ostream &out, const increasable_word& word)
{
  out << word.as_string();
  return out;
}

int main()
{
  cout<<"Wieviele Zeichen soll das Wort haben?"<<endl;
  size_t anzahl_zeichen;   
  cin >> anzahl_zeichen;

  increasable_word aktuelles_wort(anzahl_zeichen, "ABCDEFG");

  do cout << ++aktuelles_wort<<endl;
  while (! aktuelles_wort.maxed());
}

Immerhin hält es das Hauptprogramm schön übersichtlich.

Ich hatte auch an eine Lösung gedacht, mittels TMP alle erdenklichen Kombinationen zur Compilerzeit zu berechnen. Tatsächlich wäre dies sogar ziemlich einfach mit TMP. Aber mehrere Millionen Jahre Übersetzungszeit wollte ich dem Compiler dann doch nicht zumuten.

[1337shaddow]

SeppJ schrieb:

In meinem steten Streben nach unnötig komplizierten Antworten auf einfache Fragen, habe ich dieses Monstrum erschaffen:

hast du das Monstrum auch schonmal ausprobiert? Weil bei mir(Dev C++ Compiler) funzt es nicht. da kann man eine Zahl eingeben, und dann kommt nix mehr

[1337shaddow]

Jetzt weis ich, wo mein Fehler ist, aber ich weis nicht wie ich ihn loswerde. dafür hab ich einen anderen fehler gekillt! bei der if(counter == 63) hab ich vergessen, den counter wieder zurückzusetzen. Deshalb auch die komischen werte(die komischen Zeichen).

Mein Fehler ist jetzt nur noch, dass es nicht den Buchstaben, der vor dem letzten Buchstaben ist, verändert. Ich hab das jetzt mal mit einer (nicht so tollen) if abfrage gemacht. komischerweise verändert es den vorrangegangenen buchstaben trotzdem nicht.

Jetzt kommt diese ausgabe(bei 3 Buchstaben):
aaa
aab
aac
...
aa0
aa
aaa
aab
aac
aad
...

Ist doch schon besser, oder??
Aber eben noch nicht richtig

Hier ist der code:

#include <iostream>
#include <string.h>
#include <conio.h>
using namespace std;

int anzahl_zeichen, aktuelles_zeichen, counter = 0, counterIII=-1;
bool abbruch = false;
//Buchstaben und Zahlen in einem Array speichern
char alle_zeichen[63] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

int main(){
    //Liest ein wie viele zeichen das Wort aus der Brute-Force Attacke haben soll
    cout<<"Wieviele Zeichen soll das Wort haben?\n";
    cin>>anzahl_zeichen;
    //erstellt einen leeren String mit der anzahl an zeichen als Länge
    char aktuelles_wort[anzahl_zeichen];
    //Füllt das leere wort mit zeichen(immer "a")
    while(counterIII!=anzahl_zeichen-1){
         counterIII++;
         aktuelles_wort[counterIII]='a';}
         //gibt das Wort aus, da es sonst bei aa...aaab anfangen würde
         cout<< aktuelles_wort << endl;
    //Die Schleife, die die Wörter generiert und ausgibt, mit der Abbruchsbedingung, die bei bhjkfgsduf(unten) überprüft wird
    while(abbruch == false){
          //setzt den zähler, der die Position des Buchstaben angibt
          aktuelles_zeichen = anzahl_zeichen-1;
          //erhöht den counter, der den buchstaben bestimmt um eins höher
          counter++;
          //falls der counter mit der null fertig ist, wird als zeichen ein a gespeichert und das zeichen um eins zurückgesetzt
          //dann wird das so oft wiederholt, bis man beim ersten zeichen ankommt. Wenn das auch null ist wird die abbruchsbedingung erfüllt
          //und der Bool-schalter abbruch auf true gesetzt(bhjkfgsduf)
          if(counter == 63){
                 counter = 0;
                 aktuelles_wort[aktuelles_zeichen] = 'a';
                 aktuelles_zeichen--;
                 while(aktuelles_wort[aktuelles_zeichen] == '0' && aktuelles_zeichen >= 0){
                                                         aktuelles_wort[aktuelles_zeichen] = 'a'; 
                                                         aktuelles_zeichen--;
                                                         //Erhöht das andere Zeichen um eins
                                                         if(aktuelles_wort[aktuelles_zeichen] == 'a'){aktuelles_wort[aktuelles_zeichen] = 'b';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'b'){aktuelles_wort[aktuelles_zeichen] = 'c';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'c'){aktuelles_wort[aktuelles_zeichen] = 'd';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'd'){aktuelles_wort[aktuelles_zeichen] = 'e';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'e'){aktuelles_wort[aktuelles_zeichen] = 'f';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'f'){aktuelles_wort[aktuelles_zeichen] = 'g';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'g'){aktuelles_wort[aktuelles_zeichen] = 'h';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'h'){aktuelles_wort[aktuelles_zeichen] = 'i';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'i'){aktuelles_wort[aktuelles_zeichen] = 'j';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'j'){aktuelles_wort[aktuelles_zeichen] = 'k';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'k'){aktuelles_wort[aktuelles_zeichen] = 'l';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'l'){aktuelles_wort[aktuelles_zeichen] = 'm';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'm'){aktuelles_wort[aktuelles_zeichen] = 'n';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'n'){aktuelles_wort[aktuelles_zeichen] = 'o';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'o'){aktuelles_wort[aktuelles_zeichen] = 'p';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'p'){aktuelles_wort[aktuelles_zeichen] = 'q';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'q'){aktuelles_wort[aktuelles_zeichen] = 'r';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'r'){aktuelles_wort[aktuelles_zeichen] = 's';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 's'){aktuelles_wort[aktuelles_zeichen] = 't';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 't'){aktuelles_wort[aktuelles_zeichen] = 'u';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'u'){aktuelles_wort[aktuelles_zeichen] = 'v';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'v'){aktuelles_wort[aktuelles_zeichen] = 'w';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'w'){aktuelles_wort[aktuelles_zeichen] = 'x';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'x'){aktuelles_wort[aktuelles_zeichen] = 'y';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'y'){aktuelles_wort[aktuelles_zeichen] = 'z';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'z'){aktuelles_wort[aktuelles_zeichen] = 'A';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'A'){aktuelles_wort[aktuelles_zeichen] = 'B';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'B'){aktuelles_wort[aktuelles_zeichen] = 'C';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'C'){aktuelles_wort[aktuelles_zeichen] = 'D';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'D'){aktuelles_wort[aktuelles_zeichen] = 'E';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'E'){aktuelles_wort[aktuelles_zeichen] = 'F';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'F'){aktuelles_wort[aktuelles_zeichen] = 'G';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'G'){aktuelles_wort[aktuelles_zeichen] = 'H';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'H'){aktuelles_wort[aktuelles_zeichen] = 'I';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'I'){aktuelles_wort[aktuelles_zeichen] = 'J';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'J'){aktuelles_wort[aktuelles_zeichen] = 'K';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'K'){aktuelles_wort[aktuelles_zeichen] = 'L';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'L'){aktuelles_wort[aktuelles_zeichen] = 'M';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'M'){aktuelles_wort[aktuelles_zeichen] = 'N';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'N'){aktuelles_wort[aktuelles_zeichen] = 'O';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'O'){aktuelles_wort[aktuelles_zeichen] = 'P';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'P'){aktuelles_wort[aktuelles_zeichen] = 'Q';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'Q'){aktuelles_wort[aktuelles_zeichen] = 'R';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'R'){aktuelles_wort[aktuelles_zeichen] = 'S';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'S'){aktuelles_wort[aktuelles_zeichen] = 'T';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'T'){aktuelles_wort[aktuelles_zeichen] = 'U';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'U'){aktuelles_wort[aktuelles_zeichen] = 'V';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'V'){aktuelles_wort[aktuelles_zeichen] = 'W';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'W'){aktuelles_wort[aktuelles_zeichen] = 'X';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'X'){aktuelles_wort[aktuelles_zeichen] = 'Y';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'Y'){aktuelles_wort[aktuelles_zeichen] = 'Z';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == 'Z'){aktuelles_wort[aktuelles_zeichen] = '1';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '1'){aktuelles_wort[aktuelles_zeichen] = '2';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '2'){aktuelles_wort[aktuelles_zeichen] = '3';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '3'){aktuelles_wort[aktuelles_zeichen] = '4';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '4'){aktuelles_wort[aktuelles_zeichen] = '5';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '5'){aktuelles_wort[aktuelles_zeichen] = '6';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '6'){aktuelles_wort[aktuelles_zeichen] = '7';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '7'){aktuelles_wort[aktuelles_zeichen] = '8';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '8'){aktuelles_wort[aktuelles_zeichen] = '9';}
                                                         else if(aktuelles_wort[aktuelles_zeichen] == '9'){aktuelles_wort[aktuelles_zeichen] = '0';}
                                                         aktuelles_zeichen = anzahl_zeichen-1;}//von der while(aktuelles_wort[aktuelles_zeichen} == '0' ...
                 if(aktuelles_zeichen==0 && aktuelles_wort[aktuelles_zeichen] == '0'){abbruch=true;}//bhjkfgsduf
                 }//von der if(counter ==63)
          //dann wird das zeichen in dem Wort gespeichert und ausgegeben.
          aktuelles_wort[aktuelles_zeichen] = alle_zeichen[counter];
          cout<< aktuelles_wort << endl;
          getch();//nur zum testen. Wird wieder entfernt
    }//von der while(true)
    getch();
}//von der int main