Stellen herausfinden bei initialisierte chars in einem Array



  • Hallo Laserstrahl
    Probiers mal hiermit. (Nicht so elegant, aber funktioniert 🙂 )

    Bei Fragen melden.

    //edit:
    @Laserstrahl:
    Habe nun versucht den Code ganz verständlich zu dokumentieren.
    (Sorry, aber ich kann nur ganz schlecht erklären).

    #include <iostream> // Fuer die Standard Ein- und -Ausgabe (cin, cout)
    using namespace std; // Im folgenden die ganze Zeit den Namensraum std verwenden.
    
    int main()
    {
            // Alphabet im Array alpha speichern.
            const char alpha[27] = "abcdefghijklmnopqrstuvwxyz\0"; 
            unsigned int key = 1; // Schluessel zum codieren.
                         // Variabel: (kann beispielsweise auch eingelesen werden)
    
            cout << "\nBitte Text zum verschluesseln eingeben: ";
    
            char str[1000]; // Zwei char-Arrays definieren und ihnen 1000 Byte Speicherplatz zuweisen.
            char str2[1000]; // str speichert den einzulesenden Text, str2 den auszugebenden.
    
            // Eine Zeile von der Tastatur einlesen, MAX 999 Zeichen oder wenn Enter gedrueckt wurde
            cin.getline(str, 999, '\n');
    
            // Nun beginnt der eigentliche Teil (Codierung des Strings). Man koennte diesen Teil auch
            // in eine eigene Funktion schreiben (ist eleganter). Ich will diesen Quellcode aber jetzt
            // nicht unoetig verkomplizieren.
    
            // Erste For-Schleife, wird durchlaufen solange die Variable i (Am Anfang 0) kleiner als 
            // die Laenge des eingelesenen Textes (Array str). Im folgenden wird naemlich jedes
            // einzelne Zeichen seperat behandelt.
            for(unsigned int i = 0; i < strlen(str); ++i)
            {
                    // Wenn das Zeichen in dem Array str mit dem Index ein Alphabetisches Zeichen ist,
                    // geht es weiter.
                    if(isalpha(str[i]))
                    {
    
                            // Zweite For-Schleife, wird durchlaufen solange die Variable j kleiner als
                            // die Laenge des Alphabetes (26)
                            for(unsigned int j = 0; j < strlen(alpha); ++j)
                            {
                                    // In dieser If-Abfrage wird nun das aktuelle Zeichen aus dem Array
                                    // str erstmal in einen Kleinbuchstaben umgewandelt. (Falls das
                                    // nicht sowieso schon der Fall ist). Danach wird das aktuelle
                                    // Zeichen (Index i) aus dem Array str mit dem aktuellen Zeichen
                                    // (Index j) aus dem Array alpha verglichen.
    
                                    // Falls es eine Uebereinstimmung gibt, ...  
                                    if(tolower(str[i]) == alpha[j])
                                    {
                                            // dann wird geprueft, ob j + der Schluessel kleiner als die
                                            // Laenge des Alphabetes...  
                                            if(j + key < strlen(alpha))
    
                                                    // wenn ja..
                                                    // dann wird das aktuelle Zeichen verschluesselt aus 
                                                    // dem Index plus dem Schluessel.
                                                    // Beispiel:
                                                    // zu verschluesselndes Wort: "Hallo"
                                                    // Index i == 0, daher Buchstabe h (umgewandelt in
                                                    // Kleinbuchtaben) wird verschluesselt, indem der
                                                    // Index von j (7 == Buchstabe h) plus dem Schluessel
                                                    // (1) genommen wird. Also aus dem Buchstaben h wird
                                                    // mit dem Schluessel 1 ein i.
                                                    str2[i] = alpha[j + key];
                                            else
                                            {
                                                    // Falls dagegen aber das Wort "zu" verschluesselt werden
                                                    // soll (Index i wieder 0, daher buchstabe z), muss ja
                                                    // wieder bei a weitergemacht werden. Deswegen wird untige
                                                    // Berechnung durchgefuehrt. 25[Wert von j] - 26[Laenge
                                                    // des Alphabetes] == -1 + 1[Schluessel] == 0. Und da
                                                    // alpha[0] der Buchstabe a zugeordnet ist, wird der Buch-
                                                    // stabe z zu a. 
                                                    int overflow = j - strlen(alpha);
                                                    str2[i] = alpha[overflow + key];
                                            }
                                    }
                            }
                    }
                    // Falls das aktuelle Zeichen kein Alphabetisches Zeichen, dann unveraendert uebernehmen.
                    else
                            str2[i] = str[i];                        
            }
    
            str2[strlen(str)] = '\0';   // \0 anhaengen. (Stringende-Zeichen)                                     
    
            cout << "\nCodierter Text: ";
    
            // Codierten Text ausgeben.
            for(unsigned int i = 0; i < strlen(str2); ++i)
                    cout << str2[i];          
    
            cout << endl;        
            return 0;
    }
    

    Caipi 🙂



  • ...ui das ist komplex, kenne davon noch viele Elemente nicht.
    Unser Uni Prof. hat vom Stoff her noch gar nichts mit strlen, overflow und cin.getline gemacht.



  • Die Elemente, die du noch nicht kennst, sind aber leicht zu verstehen.

    1. strlen(char arr[]). Diese Funktion ermittelt die Anzahl der Zeichen des Arrays oder Pointers, welches/welcher ihr als Argument übergeben wird.

    2. Overflow ist nur ein Variablenname, lass dich davon nicht verwirren.

    3. Mit cin.getline() liest du eine Zeile von der Tastatur z.B. in ein char-Array.
    Du kannst natürlich auch nur cin >> var schreiben. Dann kannst du aber nur ein Wort eingeben, da cin >> ... bei einem Zwischenraumzeichen abbricht.

    Caipi.



  • Achja overflow ist nur eine Variable 🙄
    Aber was ist tolower bei der if anweisung?
    Ist zum Verzweifeln, hab überhaupt keine Ahnung 😞

    Ich schätze ich darf nur die Elemente verwenden die bis jetzt in der Vorlesung behandelt worden sind.



  • mach i zur variable vom typ int. dann müsste alles funktionieren. denn wenn i ein char ist werden die asci werte dafür herangezogen. siehe ascii tabelle.
    und die ausgabe machst du einfach so.

    cout << eingabe[i] << endl;
    


  • Hab deinen Tipp befolgt aber bei mir kommt immer 'a' raus, was ist denn da faul?

    #include <iostream.h> 
    
    int main() 
    { 
    
        char eingabe[52]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; 
        int i;
    
        cin>>i; 
        cout<<eingabe[i]; 
    
    return 0; 
    }
    


  • und was für einen wert hast du eingegeben?



  • Ach nein ich wollte ein char eingeben z.B Eingabe: c Ausgabe: 2
    Also muss i ein char sein.



  • Laserstrahl schrieb:

    Achja overflow ist nur eine Variable 🙄
    Aber was ist tolower bei der if anweisung?
    Ist zum Verzweifeln, hab überhaupt keine Ahnung 😞

    Kopf hoch! 👍
    Siehe nochmal meinen ersten Post, ich habe ihn nun versucht zu dokumentieren.

    Caipi 🙂



  • Vielen Dank für deine Bemühung, aber leider hilft das bei mir auch nicht viel weiter, weil ich nur das verwenden darf was in der Vorlesung behandelt worden ist...
    Bleibt wohl nur weiterbüffeln bis ich ein Ergebnis hab.



  • Wollte mal das für ein einzelnes Zeichen versuchen, aber es stürzt sofort ab, weiss nicht wieso...

    #include <iostream.h> 
    
    int main() 
    { 
    
        char n, eingabe[52], ausgabe[52]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; 
        int i,j;
    
    		cin>>eingabe;
    		ausgabe[i]=char(int(eingabe[i])+1);
    
    		cout<<ausgabe[i];
    
    return 0; 
    }
    

    z.B. ich tippe einen Buchstaben 'a' ein und es wird 'b' ausgegeben, geht aber nicht *heul*



  • @Laserstrahl
    Probiers mal so...
    (Wobei wenn du 'z' eingibst '{' ausgegeben wird, da der Ascii-Wert von 'z' + 1 == dem Ascii-Wert von '{')

    #include <iostream>
    using namespace std;
    
    int main()
    {   
            char eingabe, ausgabe; 
    
            cin >> eingabe;
            ausgabe = (int) eingabe + 1;
    
            cout << ausgabe;
    
    return 0;
    }
    

    Caipi



  • Ich versteh das nicht wieso funktioniert das ganz ohne arrays?
    Woher weiss das Programm das Alphabet? 😕



  • Das funktioniert folgendermaßen: Jedem Zeichen auf der Tastatur ist ein Zeichencode zugeordnet. AFAIK ist es hier der ASCII-Code (American Standard Code For Information Interchange). Dem Zeichen a ist der ASCII-Code 97 zugeordnet, dem b der ASCII-Code 98, c == 99, d == 100 usw.
    Dies mache ich mir nun zunutze, indem ich zu dem Zeichen-Code des eingegebenen Zeichens 1 hinzuaddiere, daher, aus a wird b, aus b wird c usw. (Aus z wird {).

    Caipi



  • Danke für die Erklärung, also hat der Tutor also auch so gemeint?
    Da brauch ich also nichts zu initialisieren oder, wenn das für einzelne Zeichen funktioniert?

    Er hat mir diesen Tipp gegeben:
    ausgabe[i]=char(int(eingabe[i])+1);

    Aber es funktioniert trotzdem nicht...
    Es kommen nur komische Symbole raus.

    #include <iostream> 
    using namespace std; 
    
    int main() 
    {   
            char eingabe[50], ausgabe[50]; 
            int i;
            cin >> eingabe; 
    
    		for(i=0; eingabe[i]<50; i++) 
    			ausgabe[i] = char(int (eingabe[i])+1); 
    
            cout << ausgabe; 
    
    return 0; 
    }
    


  • Ich habs fast geschafft, aber woher kommen jetzt die komischen Zeichen her nach der Caesar codierung?
    Kann mir das jemand erklären?
    Was ich auch nicht verstehe ist wieso funktioniert es irgendwie wenn man in der for schleife das <50 in der Schleife weglasse?

    #include <iostream> 
    using namespace std; 
    
    int main() 
    {   
            char eingabe[50], ausgabe[50]; 
            int i;
            cin >> eingabe; 
    
    		for(i=0; eingabe[i]; i++) 
    			ausgabe[i] = char(int (eingabe[i])+1); 
    
            cout << ausgabe; 
    
    return 0; 
    }
    


  • @Laserstrahl
    Du hast das Stringende-Zeichen vergessen, ohne das, werden auch die unbeschriebenen vorreservierten Bytes ausgegeben.

    #include <iostream>
    using namespace std;
    
    int main()
    {  
            char eingabe[50], ausgabe[51];
            int i;
            cin.getline(eingabe, 50, '\n'); // kannst natuerlich auch cin >> eingabe schreiben                   
                                            // cin.getline() hat aber den Vorteil, dass eine ganze Zeile eingelesen werden kann.
    
            for(i=0; eingabe[i] != '\0'; i++)
                ausgabe[i] = char(int (eingabe[i])+1);
    
            ausgabe[i] = '\0'; // Stringende-Zeichen zuweisen.
            cout << ausgabe;
    
    return 0;
    }
    


  • Danke nochmal, du warst echt eine grosse Hilfe für mich! 🙂

    Ich hätte noch eine Frage, das '\0' bewirkt in der Schleife das Stringende, also sobald das Ende der Eingabe erreicht wird.

    Aber wieso muss ich wieder '\0' an ausgabe[i] zuweisen?
    Wenn ich das weglasse wird gar nichts ausgegeben.



  • AFAIK wird, wenn du einem char-Array arr 50 Byte Speicher zuweist, danach z.B. nur 12 Byte Speicher mit Werten (Zeichen) belegst und dann cout << arr; schreibst, der gesammte String ausgegeben und somit auch die von dir nicht belegten Bytes. (Das führt zu den komischen Zeichen am Ende).
    Wenn du aber z.B. ausgabe[12], also dem 13 Byte das Stringende-Zeichen zuweist und dann cout << arr; schreibst, wird das Array nur bis zum Stringende-Zeichen ausgegeben.

    P.S.: Vielleicht fragst du dich, warum z.B. in deinem Array eingabe komische Zeichen stehen (Außer an den Stellen denen du einen Wert zugewiesen hast). Dies liegt daran, dass lokal definierte Variablen - soweit du das nicht änderst - mit gar nichts (und somit mit irgend etwas) initialisiert werden.

    Caipi


Anmelden zum Antworten