Ausnahmebehandlung für eine string Funktion



  • 2 und 3 lassen sich zuusammen ermitteln, in dem Du durch den String durchläufst und dabei nicht nur testest, ob ungültiges Zeichen sopndern auch ob gültiges Zeichen vorhanden ist. Daher merkvariable vorher auf null setzen und bei gültigem Zeichen auf 1

    .

    Funktioniert nicht.Wenn ich nickname auf null setze, bekomme ich einenen Fehler:

    error: declaration of 'std::string nickname' shadows a parameter



  • Hi Helenchen,

    helenchen schrieb:

    2 und 3 lassen sich zuusammen ermitteln, in dem Du durch den String durchläufst und dabei nicht nur testest, ob ungültiges Zeichen sopndern auch ob gültiges Zeichen vorhanden ist. Daher merkvariable vorher auf null setzen und bei gültigem Zeichen auf 1

    .

    Funktioniert nicht.Wenn ich nickname auf null setze, bekomme ich einenen Fehler:

    error: declaration of 'std::string nickname' shadows a parameter

    Das war leider ein Schreibfehler von mir, da muss es 0 heißen.
    Und Du sollst ja auch in der Funktion nick nicht den Nicknamen auf Null setzen, sondern nur die Merkvariable. Nenn sie einfach GueltigVorhanden.
    Die Variable setzt Du beim erstellen in der Nick-Funktion gleich auf 0 und wenn du beim Parsen von Nickname ein gültiges Zeichen findest setzt Du GueltigVorhnden auf 1.

    Aufrufen kannst Du nick aber aus meiner sicht in Main trotzdem mit NULL

    nick( NULL );
    

    müsste zulässig sein, eventuell nach string gecastet. Aber es müsste auch ohne Cast gehen, denn NULL ist eigentlich zu allem zuweisungscompatibel.

    PS: Wo bleibt ein richtig formatierter Quelltext?

    Gruß Mümmel



  • Wie parst man einen String ( habe alles ausgegoogelt nicht gescheites)

    ⚠ Leider sieht mein Code katastrophal aus 👎 :

    #include <iostream>
    #include<stdexcept>
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick (string nickname, string GueltigVorhanden=0){
    
       if(( nickname != GueltigVorhanden) || (nickname == GueltigVorhanden))
           throw runtime_error{ "nick(), nicht string"};
    
       else
           throw runtime_error{" nick(), string"};
    
       return nickname;
       }
    
    int main() {
    
    try{
        nick(NULL);   
    
       return 0;
    
        }
    
    catch ( const runtime_error& re ) {
    
    cerr << "Caught: " << re.what( ) << endl;
    
    return -1;
    
      }
    
    }
    

    gibt es da nicht andere Möglichkeit es zu machen ?
    😞
    PS: Je mehr ich über Exceptions lese desto schlimmer wird es 😃



  • Hinweis am Rande: installer dir mal ReSharper für C++ (mit Studentenausweis gratis) und drück CTRL+E und dann F für "Format Code" und poste erst dann Code.

    MfG SideWinder



  • Hi Helenchen,

    Eigentlich wollte ich ja nicht mehr antworten, wenn Du wieder unformatierten Müll postest, aber noch kurz nen Hinweis.

    helenchen schrieb:

    Wie parst man einen Strin1g ( habe alles ausgegoogelt nicht gescheites)
    gibt es da nicht andere Möglichkeit es zu machen ?

    kommt auf den jeweiligen Zweck an. In dem Fall ist es leicht:

    function nick
      int GueltigVorhanden = 0;
      wenn nick == NULL runtime_error{ "Nullwert übergeben"};
      Vom ersten bis zum letzten Zeichen gehen und jedes Zeichen angucken.
        wenn >= 'a' und <= 'z' oder >= 'A' und <='Z' 
            oder gleich ä oder gleich ö oder gleich ü 
            oder gleich Ä oder gleich Ö oder gleich Ü oder gleich ß 
          GueltigVorhanden = 1
        sonst
          wenn Zeichen != ' '
            throw runtime_error{ "verbotenes Zeichen"};
      wenn GueltigVorhanden == 0
        runtime_error{ "Leere Zeichenkette übergeben"};
    

    Nun musst Du nur noch ordentlichen Quelltext draus machen. Tipp von mir:ausgiebig klammern.

    PS: Je mehr ich über Exceptions lese desto schlimmer wird es 😃

    Nicht die Exceptions sind Dein Problem, sondern die Auswertung ob der String gültig ist.

    Ob er String in c++ von 1 bis n geht oder von 0 bis n-1 weiß ich nicht mehr. Der darunter liegende c_String geht auf jeden fall von 0 bis n-1 und an n liegt die /0 als Endekennzeichen. Im Notfall hätte ich den gezogen und ausgewertet. Auf dem Tablet kann ich aber auch nicht mehr als auf meinen Kopf zurückgreifen.
    Ich glaube mich aber zu erinnern, dass Du Anfang und Ende wie bei einem Vektor ermitteln konntest.
    Auch wenn Du wie SideWinder sagt ReSharper installierst solltest Du doch auch das Formatieren von Hand perfekt beherrschen. Es ist nur eine kleine Mühe und hilft beim Verstehen des Codes.

    Gruß Mümmel



  • Frage zum ReSharper , so wie ich gesehen habe gibt es dem nur für Visual Studio ich programmiere aber mit NetBeans. Klappt das nicht mit normalen Code Editor ( ich meine der das Code lesen kann wo es immer auch alles schön Aussieht 😃 )?



  • Hi Helenchen,

    einen Online-Formatierer für einen ersten Überblick findest Du hier.
    http://format.krzaq.cc/
    Du musst das Ergebnis aber noch ein wenig nacharbeiten.
    Ganz unten hast Du die Auswahl des Styles (nimm file) und den Button zum Starten.

    Gruß Mümmel



  • Hi Helenchen,

    mit dem Online-Formatierer überarbeitet sähe Dein Quelltext so aus:

    #include <iostream>
    #include <stdexcept>
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick(string nickname, string GueltigVorhanden = 0)
    {
    
        if ((nickname != GueltigVorhanden) || (nickname == GueltigVorhanden))
            throw runtime_error{ "nick(), nicht string" };
    
        else
            throw runtime_error{ " nick(), string" };
    
        return nickname;
    }
    
    int main()
    {
    
        try
        {
            nick("capitalQ");
    
            return 0;
        }
    
        catch (const runtime_error& re)
        {
    
            cerr << "Caught: " << re.what() << endl;
    
            return -1;
        }
    }
    

    Ist schon mal nicht das verkehrteste, sauberer Allman-Stil, so wie ich ihn Dir ganz fest ans Herz legen würde.

    Und so würde ich es machen: (den Test auf NULL habe ich übrigens bei meinem Compiler nicht hinbekommen.)

    #include <iostream>
    #include <string>
    #include <stdexcept>
    
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick(string nickname )
    {
      if ( nickname.empty() )                      // wenn leere Zeichenkette
        throw runtime_error( "NickName ist leer" );
    
      int GueltigVorhanden = 0;                    // Vorbelegen auf Falsch
      for ( std::string::iterator it=nickname.begin(); it!=nickname.end(); ++it)   // durch alle Zeichen gehen
      {
        if ( ( *it >= 33 ) && ( *it <= 126 ) )     // wenn erlaubtes ASCII-Zeichen ich hab hier mal
                                                   // auf alle druckbaren Zeichen erweitert (Test einfacher)
        {
          GueltigVorhanden = 1;                    // nicht nur Leerzeichen
        }
        else                                       // sonst wenn kein erlaubtes
        {
          if ( *it != ' ' )                        // und wenn es kein Leerzeichen ist
          {
            throw runtime_error( "Unzulässiges Zeichen" );  // muss es ein falsches sein, also Exception werfen
          }
        }
      }
      if ( GueltigVorhanden == 0 )
        throw runtime_error( "NickName enthält nur Leerzeichenn" );
      return nickname;
    }
    
    int main(int argc, _TCHAR* argv[])
    {
        string x;
        string Nick_Name;
      try
      {
        Nick_Name = nick( "\ncapitalQ" );
        cout << "Gültiger NickName eingegeben" << endl;
                                     // Eingabe damit Ergebnis sthen bleibt
        cout << "Eingabe für weiter" << endl;
        cin >> x;
    
        return 0;
      }
      catch (const runtime_error& re)
      {
        cerr << "Error: " << re.what() << endl;
        cout << "Eingabe für weiter" << endl;
        cin >> x;
        return -1;
      }
    }
    

    Gruß Mümmel



  • hier ist mein Code leider immer noch fehlerhaft

    #include <iostream>
    #include <stdexcept>
    #include <string>
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick(string nickname)
    {
    
        int GueltigVorhanden = 0;
    
        if (nick == NULL)
            throw runtime_error{ " nick(), Nullwert übergeben " };
    
        for (size_t i = 0; i < nickname.size(); ++i)
            ;
        if (((nickname >= 'a' && nickname <= 'z' || nickname >= 'A' && nickname <= 'Z')
                || (nickname == 'ae' || nickname == 'oe' || nickname == 'ue'))
            || (nickname == 'AE' || nickname == 'OE' || nickname == 'UE' || nickname == 'SS'))
    
            GueltigVorhanden = 1;
    
        else if (nick != '')
            throw runtime_error{ " nick(), verbotenes Zeichen" };
        if (GueltigVorhanden == 0)
            throw runtime_error{ " nick(), Leere Zeichenkette übergeben" };
    }
    
    int main()
    {
    
        try {
    
            nick(NULL);
    
            return 0;
        }
    
        catch (const runtime_error& re) {
    
            cerr << "Caught: " << re.what() << endl;
    
            return -1;
        }
    }
    

    was meintest du hier Mümmelchen?

    wenn >= 'a' und <= 'z' oder >= 'A' und <='Z'
    oder gleich ä oder gleich ö oder gleich ü
    oder gleich Ä oder gleich Ö oder gleich Ü oder gleich ß

    und

    wenn Zeichen != ' '

    das sind die meist Fehlerhaften Zeilen bei mir . Habe ich da mal wieder was falsch verstanden? 🙄



  • Hi Helenchen,

    Zeichen != '' geht nicht, da muss zumindest ein Leerzeichen rein.
    Und den Rest solltest Du vernünftig ergänzen. Ich hab Dir nur hingeschrieben, was Du für Tests machen sollst.
    Ich hab Deine Fehler mal auskommentiert und etwas kommentiert. Bitte alles lesen.

    string nick(string nickname)
    {
    
        int GueltigVorhanden = 0;                         // soweit OK
    
    //    if (nick == NULL)                                          // hab ich nicht zum laufen bekommen
    //        throw runtime_error{ " nick(), Nullwert übergeben " }; // mein Compiler weigerte sich, mit NULL zu vergleichen
    
    //    for (size_t i = 0; i < nickname.size(); ++i) // nimm für Strings besser die Variante, die ich aufgeschrieben habe, 
                                                       // müsste aber auch so gehen.
    
            ;                                          // mit dem Semikolon als Schleifenkörper beendest Du die Schleife 
                                                       // ohne was zu tun.
    
    // Du vergleichst hier wirklich nen String mit nem einzelnen Zeichen???
    
    //    if (((nickname >= 'a' && nickname <= 'z' || nickname >= 'A' && nickname <= 'Z')
    //            || (nickname == 'ae' || nickname == 'oe' || nickname == 'ue'))             
    //        || (nickname == 'AE' || nickname == 'OE' || nickname == 'UE' || nickname == 'SS'))
    
    // ich hatte nicht umsonst geschrieben "Tip von mir: ausgiebig klammern"
    
    // ich würde mich nicht darauf verlassen, dass der Compiler 'ae' als 'ä' interpretiert
    
    // mache es besser so
        for (size_t i = 0; i < nickname.size(); ++i)
        {
            if (
                 ( ( nickname[ i ] >= 'a' ) && ( nickname[ i ] <= 'z' ) ) ||
                 ( ( nickname[ i ] >= 'A' ) && ( nickname[ i ] <= 'Z' ) ) ||
                 ( nickname[ i ] == 'ä' ) ||
                 ( nickname[ i ] == 'ö' ) ||
                 ( nickname[ i ] == 'ü' ) ||
                 ( nickname[ i ] == 'Ä' ) ||
                 ( nickname[ i ] == 'Ö' ) ||
                 ( nickname[ i ] == 'Ü' ) ||
                 ( nickname[ i ] == 'ß')
               )                               // mit Zeiger statt Indexzugriff wäre es performanter
                                               // geht aber auch so
            {
                GueltigVorhanden = 1;
            }
            else
            {
              if ( nickname[ i ] != ' ' )
              {
                throw runtime_error( " nick(), verbotenes Zeichen" );
              }
            }
        }
        if (GueltigVorhanden == 0)
        {
            throw runtime_error( " nick(), Leere Zeichenkette übergeben" );
        }
    }
    
    int main(int argc, _TCHAR* argv[])
    {
        string x;
    
        try {
    
            nick("/nOma");
    
            return 0;
        }
    
        catch (const runtime_error& re) {
    
            cerr << "Caught: " << re.what() << endl;
    
        cout << "Eingabe für weiter" << endl;
        cin >> x;
            return -1;
        }
        cout << "Eingabe für weiter" << endl;
        cin >> x;
    }
    

    Gruß Mümmel



  • leider meckert compiler auf die umlaute => multi - character char:

    #include <iostream>
    #include <stdexcept>
    #include <string>
    
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick(string nickname)
    {
        if (nickname.empty()) // wenn leere Zeichenkette
            throw runtime_error("NickName ist leer");
    
        int GueltigVorhanden = 0; // Vorbelegen auf Falsch
        for (size_t i = 0; i < nickname.size(); ++i) // durch alle Zeichen gehen
        {
            if (
                   ((nickname[i] >= 'a') && (nickname[i] <= 'z'))
                || ((nickname[i] >= 'A') && (nickname[i] <= 'Z'))
                || (nickname[i] == 'ä')
                || (nickname[i] == 'ö')
                || (nickname[i] == 'ü')
                || (nickname[i] == 'Ä')
                || (nickname[i] == 'Ö')
                || (nickname[i] == 'Ü')
                || (nickname[i] == 'ß')
               )
            {
                GueltigVorhanden = 1; // nicht nur Leerzeichen
            }
            else // sonst wenn kein erlaubtes
            {
                if (nickname[i] != ' ') // und wenn es kein Leerzeichen ist
                {
                    throw runtime_error(
                        " nick(), verbotenes Zeichen "); // muss es ein falsches sein,
                    // also Exception werfen
                }
            }
        }
    
        if (GueltigVorhanden == 0) {
            throw runtime_error{ " nick(), Leere Zeichenkette übergeben" };
        }
    }
    
    int main()
    {
        string x;
    
        try {
            nick(" /ncapitalQ ");
    
            return 0;
        }
    
        catch (const runtime_error& re) {
            cerr << " Caught: " << re.what() << endl;
    
            cout << " Eingabe für weiter " << endl;
            cin >> x;
    
            return -1;
        }
        cout << " Eingabe für weiter " << endl;
        cin >> x;
    }
    

    habe versucht es durch setlocal zu beheben keine Chance 👎



  • Hi Helenchen,

    lass entweder die Umlaute weg, dann können im Nickname eben keine Umlaute verwendet werden, oder verwende den Numerischen Wert der Umlaute.
    Dabei musst Du dann aber ein wenig casten für den Vergleich.
    Entweder
    ( (int) nickname[i] == 196 ) // 196 = Ä, zumindest in Codeseite (Win-1252)
    oder
    ( nickname[i] == (char) 196 )
    Ich würde die zweite Form schöner finden, weil es ja auf einen char-Vergleich ankommt.
    Probiere notfalls aus, was die Umlaute bei Dir für einen Wert haben.
    Lies dazu ÄÖÜäöüß von der Konsoleneingabe (cin) ein und gib die einzelnen Zahlenwerte von den 7 Zeichen nach cout aus.
    etwa so

    string x;
    cout << "Gib die Umlautreihe ein" << endl;
    cin >> x;
    cout << (int) x[0] << '|' <<(int) x[1] << '|' << (int) x[2[e]cap[/e]] 
    << '|' << (int) x[3] << '|' << (int) x[4] << '|' << (int) x[5] << '|' << (int) x[6] << '|' <<  endl;
    

    Viel Erfolg, viel Spaß und eine gute Nacht wünscht Mümmel.

    PS: Gefährliche Falle, habs eben noch schnell korrigiert. Sieben Zeichen gehen ja von 0 nur bis 6 und nicht bis 7.

    Gruß Mümmel



  • muemmel schrieb:

    den Test auf NULL

    Wenn dann würde ich eh auf nullptr testen. Und verwirr bitte die Anfänger nicht mit _TCHAR und ähnlichem.



  • Hi Tyrdal,

    Tyrdal schrieb:

    muemmel schrieb:

    den Test auf NULL

    Wenn dann würde ich eh auf nullptr testen.

    Muss ich mal, wenn ein bisschen Zeit ist probieren.

    Und verwirr bitte die Anfänger nicht mit _TCHAR und ähnlichem.

    Das baut meine Entwicklungs-Umgebung so als Vorgabe zusammen. (c++Builder xe2)

    Gruß Mümmel



  • nullptr ist der aktuelle Standard und _TCHAR nicht, sondern Windows-spezifisch.



  • habe die Umlaute weggemacht. Ausgabe meiner Meinung nicht korrekt:

    #include <iostream>
    #include <stdexcept>
    #include <string>
    
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick(string nickname)
    {
        if (nickname.empty()) // wenn leere Zeichenkette
            throw runtime_error("NickName ist leer");
    
        int GueltigVorhanden = 0; // Vorbelegen auf Falsch
        for (size_t i = 0; i < nickname.size(); ++i) // durch alle Zeichen gehen
        {
    
            if (
                ((nickname[i] >= 'a') && (nickname[i] <= 'z')) || 
                ((nickname[i] >= 'A') && (nickname[i] <= 'Z'))
               )
    
            {
                GueltigVorhanden = 1; // nicht nur Leerzeichen
            }
            else // sonst wenn kein erlaubtes
            {
                if (nickname[i] != ' ') // und wenn es kein Leerzeichen ist
                {
                    throw runtime_error(" nick(), verbotenes Zeichen ");
                // muss es ein falsches sein, also Exception werfen
                }
            }
        }
    
        if (GueltigVorhanden == 0) {
            throw runtime_error{ " nick(), Leere Zeichenkette übergeben" };
        }
    }
    
    int main()
    {
    
        string x;
    
        try {
    
            nick(" /ncapitalQ ");
    
            return 0;
        }
    
        catch (const runtime_error& re) {
    
            cerr << " Caught: " << re.what() << endl;
    
            cout << " Eingabe für weiter " << endl; 
            cin >> x; // gibt immer aus =>  nick(), verbotenes Zeichen
                     //  Eingabe für weiter a ergibt weiter nichts
    
            return -1;
        }
    }
    

    Passiert es vielleicht weil nick() schon ein string im Main stehen hat?
    das Compiler denkt ach nickname nicht leer ist also verbotenes Zeichen.
    cout und cin ergeben irgendwie keinen sinn am ende. Kann man die direkt nach catch reinmachen?



  • Hi Helenchen,

    helenchen schrieb:

    Passiert es vielleicht weil nick() schon ein string im Main stehen hat?
    das Compiler denkt ach nickname nicht leer ist also verbotenes Zeichen.
    cout und cin ergeben irgendwie keinen sinn am ende. Kann man die direkt nach catch reinmachen?

    Mal in Ruhe selber überlegen, warum der Computer einen Fehler ausgibt! 😉
    Die Zeichenkette " /ncapitalQ " hat nach dem Leerzeichen am Anfang das Zeichen /n. Das sind keine zwei einzelnen Zeichen in C und c++ sondern es ist eine sogenannte Escape-Sequenz die als Symbol für einen Zeilenvorschub steht. Das gilt aber nur zur Compilierzeit. Der Compiler wandelt das dann um in das eine Zeichen für einen Zeilenvorschub (ich glaube 13). Aber das geht nur zur Compilierzeit.
    Bei einer normalen Eingabe über die Tastatur wären es zwei Zeichen.
    Das /-Zeichen ist in C das sogenannte "Fluchtsymbol" das dem nächsten Zeichen eine Sonderbedeutung zuordnet. Will man aber zur Compilierzeit das Zeichen / selbst darstellen muss man es durch // darstellen. " //ncapitalQ " wäre also im Gegensatz dazu ein zulässiger Nickname, wenn Du nur auf 33-125 getestet hättest. So mit der Eingrenzung auf nur Groß- und Kleinbuchstaben wäre es natürlich auch ein Fehler gewesen. /n ist aber in jedem Fall ein Fehler, schon deshalb, weil es keinen gültigen Nicknamen geben kann, der mit einem Zeilenvorschub am Anfang beginnt, weil Du den an der Konsole beim Anmelden nie eingeben könntest denn es würde immer als Ende der Eingabe interpretiert.

    Vielleicht war ja das /n am Anfang des Nicknamens der Fehler den ihr mit Eurer Testfunktion finden solltet.

    Cout und cin am Ende sollen verhindern, dass das Programm gleich geschlossen wird und das Konsolen-Fenster sofort wieder zu geht. Wenn Du es aus Command startest müsste es auch ohne gehen.
    Klar, in dem speziellen Fall könntest Du es theoretisch auch gleich nach catch "reinmachen" (reinmachen kannst Du höchsten in Deine Hosen wenns Essen verdorben war 😃 ).
    Dadurch dass nach dem Aufruf von Nick nichts mehr passiert, würde das nichts ändern. Aber schon wenn Du am Schluss noch mal den Nicknamen ausgeben würdest wäre er nicht zu sehen, weil dann die Wartestelle mit cout und cin entweder nicht angesprungen würde und das Programm daher gleich zumacht oder wenn nicht fehlerhaft die Ausgabe durch den direkten Sprung in die Ausnahmebehandlung übersprungen würde.

    Gruß Mümmel



  • hier ist der code :

    #include <iostream>
    #include <stdexcept>
    #include <string>
    
    using namespace std;
    
    // Definition einer Funktion vom Typ std::string namens nick (nickname):
    string nick(string nickname)
    {
    
        if (nickname.empty()) // wenn leere Zeichenkette
            throw runtime_error("NickName ist leer");
    
        int GueltigVorhanden = 0; // Vorbelegen auf Falsch
        for (size_t i = 0; i < nickname.size(); ++i) // durch alle Zeichen gehen
        {
    
            if (
                ((nickname[i] >= 'a') && (nickname[i] <= 'z')) || 
                ((nickname[i] >= 'A') && (nickname[i] <= 'Z'))
               )
            // mit Zeiger statt Indexzugriff wäre es performanter
            // geht aber auch so
            {
                GueltigVorhanden = 1; // nicht nur Leerzeichen
            }
            else // sonst wenn kein erlaubtes
            {
                if (nickname[i] != ' ') // und wenn es kein Leerzeichen ist
                {
                    throw runtime_error(" nick(), verbotenes Zeichen "); // muss es ein falsches sein, also Exception werfen
                }
            }
        }
    
        if (GueltigVorhanden == 0)
    
            throw runtime_error{ " nick(), Leere Zeichenkette übergeben" };
    
        return nickname;
    }
    
    int main()
    {
    
        string x;
        string Nick_Name;
        try {
    
            Nick_Name = nick("\ncapitalQ");
            cout << "Bitte richtigen Nick_Name eingeben:" << endl;
            // Eingabe damit Ergebnis sthen bleibt
            cout << "Eingabe für weiter" << endl;
            cin >> x;
    
            return 0;
        }
    
        catch (const runtime_error& re) {
            cout << " Eingabe für weiter " << endl;
            cin >> x;
            cerr << " Caught: " << re.what() << endl;
    
            return -1;
        }
    }
    

    alles was ich herausbekommen habe :

    Funktion ist tatsächlich leer, über cin werden die Zeichen eingegeben aber werden irgendwie nicht weiter verarbeitet.

    Nach paar Veränderungen gibt es nur verbotene Zeichen Meldung.
    zwischen for und if anweisung mit nick[i] fehlt noch was. Also nach zeichen durchgehen muss eine if mit prüfbereich für nick[i] geben. Damit es nicht nur leerzeichen sind.

    das mit dem if( *it <= zahl etc ) funktioniert bei mir nicht

    😃 Mümmel kannst du paar Tipps dem C++ Anfängerdössel geben? ich sitze hier und weiß nicht weiter 😕



  • muemmel schrieb:

    Die Zeichenkette " /ncapitalQ " hat nach dem Leerzeichen am Anfang das Zeichen /n. Das sind keine zwei einzelnen Zeichen in C und c++ sondern es ist eine sogenannte Escape-Sequenz
    die als Symbol für einen Zeilenvorschub steht. Das gilt aber nur zur Compilierzeit. Der Compiler wandelt das dann um in das eine Zeichen für einen Zeilenvorschub (ich glaube 13).

    Das tut der compiler garantiert nicht. Waere es eine escape-sequence, dann vielleicht aber SLASH+n ist definitiv keine... \n fyi



  • Hi Cardiac,

    Cardiac schrieb:

    muemmel schrieb:

    Die Zeichenkette " /ncapitalQ " hat nach dem Leerzeichen am Anfang das Zeichen /n. Das sind keine zwei einzelnen Zeichen in C und c++ sondern es ist eine sogenannte Escape-Sequenz
    die als Symbol für einen Zeilenvorschub steht. Das gilt aber nur zur Compilierzeit. Der Compiler wandelt das dann um in das eine Zeichen für einen Zeilenvorschub (ich glaube 13).

    Das tut der compiler garantiert nicht. Waere es eine escape-sequence, dann vielleicht aber SLASH+n ist definitiv keine... \n fyi

    Ja, Danke! Das hatte ich vertauscht. Die Funktion sollte den Fehler in der Zeichenkette finden und da haben sich die Augen automatisch an "/n" festgebissen und das gelesen was sie lesen wollten.
    Wenn ich mir das selber noch mal laut vorgelesen hätte, wäre mit sicher auchaufgegangen, das '/' kein Backslash ist. Man soll halt lesen was da steht und nicht was man lesen will. 😉

    Gruß Mümmel


Anmelden zum Antworten