switch me off!



  • @Lou-Cyphr3 das werden dann 12 case bei 4 switch.
    wie wäre es mit 1 switch und 9 case?


  • Gesperrt

    @DirkB sagte in switch me off!:

    @Lou-Cyphr3 das werden dann 12 case bei 4 switch.
    wie wäre es mit 1 switch und 9 case?

    11,12,13,
    21,22,23
    31,32,33

    also 3 * 3 cases,
    bei einem switch: 9+default = 10.
    bei 4 switch: 9+4*default = 13.



  • @RBS2 sagte in switch me off!:

    == bei Strings vergleicht ihre Adressen.

    Quatsch, sofern hier gerade von std::strings die Rede ist.



  • @RBS2 sagte in switch me off!:

    bei 4 switch: 9+4*default = 13.

    Nö. 12 + 4*default = 16;

    switch(a) hat 3 case und ein default.
    Jeder case von a hat ein switch(b) mit ebenso 3 case und ein default.


  • Gesperrt

    @DirkB sagte in switch me off!:

    @RBS2 sagte in switch me off!:

    bei 4 switch: 9+4*default = 13.

    Nö. 12 + 4*default = 16;

    switch(a) hat 3 case und ein default.
    Jeder case von a hat ein switch(b) mit ebenso 3 case und ein default.

    Hast recht.

    switch (a)
       
       case 1:
       switch (b)
          case 1:
          case 2:
          case 3:
          default:
       
       case 2:
       switch (b)
          case 1:
          case 2:
          case 3:
          default:
    
       case 3:
       switch (b)
          case 1:
          case 2:
          case 3:
          default:
      
    default: // von switch(a)
    


  • Hallo,

    ich hab jetzt ein default-Problem.

    #include <iostream>
    using namespace std;
    
    int main() {
        unsigned short a,b;
        cout << "Erste Ziffer (1..3): ";
        cin >> a;
        cout << "Zweite Ziffer (1..3): ";
        cin >> b;
    
        switch (a) {
          case 1 :
    
              switch (b){
                   case 1 :
                        cout << "Elf" << endl;
                            break;
    
                  case 2 :
                       cout << "zwölf" << endl;
                            break;
                  case 3 :
                       cout << "Dreizehn" << endl;
                            break;
                  default : "falsch 1 \n";
                        }
    
         case 2 :
    
              switch (b){
                     case 1 :
                          cout << "Einundzwanzig" << endl;
                             break;
    
                     case 2 :
                          cout << "Zweiundzwanzig" << endl;
                             break;
                     case 3 :
                          cout << "Dreiundzwanzig" << endl;
                             break;
    
    
                     default : cout << " falsch 2 \n";
                            }
    
           case 3 :
    
              switch (b){
                    case 1 :
                         cout << "Einunddreissig" << endl;
                                               break;
    
                    case 2 :
                         cout << "Zweiunddreissig" << endl;
                              break;
                    case 3 :
                        cout << "Dreiunddreissig" << endl;
                              break;
                    default :  cout<< " falsch 3 \n";
    
                                              }
              default : cout << "a falsch \n";    
                      }
    
        return 0;
    }
    

    Aus welchem Grund gibt es mir immer zusätzlich eine Falsche Eingabe
    für a zurück?



  • Dann hast du offensichtlich irgendwo ein break vergessen.



  • So ist es . Danke @spiri
    Waren gleich 3



  • @Lou-Cyphr3 Du solltest deinem Compiler sagen, dass er dich davor warnt!

    Wenn ich den Code aus deinem Post mit g++ -Wall -Wextra missingbreak.cpp kompiliere, bekomme ich:

    g++ missingbreak.cpp -Wall -Wextra
    missingbreak.cpp: In function ‘int main()’:
    missingbreak.cpp:25:38: warning: statement has no effect [-Wunused-value]
                   default : "falsch 1 \n";
                                          ^
    missingbreak.cpp:43:33: warning: this statement may fall through [-Wimplicit-fallthrough=]
                      default : cout << " falsch 2 \n";
                                ~~~~~^~~~~~~~~~~~~~~~~
    missingbreak.cpp:46:8: note: here
            case 3 :
            ^~~~
    missingbreak.cpp:59:32: warning: this statement may fall through [-Wimplicit-fallthrough=]
                     default :  cout<< " falsch 3 \n";
                                ~~~~^~~~~~~~~~~~~~~~~
    missingbreak.cpp:62:11: note: here
               default : cout << "a falsch \n";
               ^~~~~~~
    

    Und clang sagt:

    clang++-7 missingbreak.cpp -Weverything -std=c++17
    missingbreak.cpp:25:25: warning: expression result unused [-Wunused-value]
                  default : "falsch 1 \n";
                            ^~~~~~~~~~~~~
    missingbreak.cpp:28:6: warning: unannotated fall-through between switch labels [-Wimplicit-fallthrough]
         case 2 :
         ^
    missingbreak.cpp:28:6: note: insert '[[fallthrough]];' to silence this warning
         case 2 :
         ^
         [[fallthrough]]; 
    missingbreak.cpp:28:6: note: insert 'break;' to avoid fall-through
         case 2 :
         ^
         break; 
    missingbreak.cpp:46:8: warning: unannotated fall-through between switch labels [-Wimplicit-fallthrough]
           case 3 :
           ^
    missingbreak.cpp:46:8: note: insert '[[fallthrough]];' to silence this warning
           case 3 :
           ^
           [[fallthrough]]; 
    missingbreak.cpp:46:8: note: insert 'break;' to avoid fall-through
           case 3 :
           ^
           break; 
    missingbreak.cpp:62:11: warning: unannotated fall-through between switch labels [-Wimplicit-fallthrough]
              default : cout << "a falsch \n";
              ^
    missingbreak.cpp:62:11: note: insert '[[fallthrough]];' to silence this warning
              default : cout << "a falsch \n";
              ^
              [[fallthrough]]; 
    missingbreak.cpp:62:11: note: insert 'break;' to avoid fall-through
              default : cout << "a falsch \n";
              ^
              break; 
    4 warnings generated.
    

    Du siehst noch eine andere Warnung in beiden Ausgaben (unused-value), das ist auch noch ein Fehler in deinem Code.



  • Dieser Beitrag wurde gelöscht!


  • @Jockelx sagte in switch me off!:

    @RBS2 sagte in switch me off!:

    == bei Strings vergleicht ihre Adressen.

    Quatsch, sofern hier gerade von std::strings die Rede ist.

    Wie ist es denn nun richtig?



  • @DirkB sagte in switch me off!:

    @RBS2 ein switch(a*10+b) geht auch



  • @wob Stimmt. da hatte ich das cout vergessen.
    Wie sage ich denn dem Compiler, dass er mich warnt?



  • @Lou-Cyphr3

    mit [...] -Wall -Wextra [...] kompiliere[n]



  • Mal ein Gegenvorschlag: Generell ist es ziemlich mühselig, die einzelnen Ziffern zu betrachten, vor allen Dingen unnötig (in deinem Fall natürlich auch unvollständig), da Zahlen zumindest im Deutschen einem klaren Muster mit nur wenigen Ausnahmen folgen (das ist im Französischen natürlich etwas anders - das bekomme ich aber ehrlicherweise nicht mehr auf die Schnelle zusammen).
    Sonderfälle sind nur ein/eins, 11, 12, 16, 17.
    Mit switch wäre es mit wirklich einfacher Programmierung so möglich:

    std::string UpTo19(uint32_t val, bool isOne=false)
    {
    	switch(val)
    	{
    	  case 0: return "Null";
    	  case 1:
    	    if(isOne)
    	      return "eins";
    	  else
    	    return "ein";
    	  case 2: return "zwei";
    	  //... 3 bis 12
    	  case 16: return "sechzehn";
    	  case 17: return "siebzehn";
    	  default:return UpTo19(val%10)+"zehn";
    	}
    }
    
    std::string UpTo99(uint32_t val, bool isOne=false)
    {
    	if(val<20) return UpTo19(val, isOne);
    	std::string word;
    	if(val%10)
    	  word=UpTo19(val%10, false)+"und";
    	switch(val/10)
    	{
    	  case 2: word+="zwanzig"; break;
    	  // 3 bis 9 (30-90) einfügen 
    	}  
    	return word;
    }
    

    Bis 100: https://ideone.com/gvTL10
    Und so könnte das eben noch für Zahlen >=100 erweitert werden.
    Bis 999:

    std::string UpTo999(uint32_t val, bool isOne)
    {
    	if(val<100)
    	  return UpTo99(val, isOne);
    	std::string word=UpTo19(val/100, false);
    	word+="hundert";
    	if(val%100)
    	  word+=UpTo99(val%100, isOne);
    	return word;
    }
    

    Nach dem gleichen Muster dann noch UnderMillion/Billion/Trillion und du kannst den kompletten 32-Bit-Bereich abdecken:

    std::string AsString(uint32_t val)
    {
    	std::string word=UnderTrillion(val);
    	// ggf. Großschreibung
            word[0]=std::toupper(word[0]);
    	return word;
    }
    

  • Gesperrt

    @DirkB Deine Version: 😺

    #include <iostream>
    using namespace std;
    
    int main()
    {
        unsigned short a,b;
        cout << "Erste Ziffer (1..3): ";
        cin >> a;
        cout << "Zweite Ziffer (1..3): ";
        cin >> b;
        string txt;
        switch (10*a+b)
        {
            case 11: txt="elf"; break;
            case 12: txt="zwoelf"; break;
            case 13: txt="dreizehn"; break;
            case 21: txt="einundzwanzig"; break;
            case 22: txt="zeiundzwanzig"; break;
            case 23: txt="dreiundzwanzig"; break;
            case 31: txt="einunddreißig"; break;
            case 32: txt="zweiunddreißig"; break;
            case 33: txt="dreiunddreißig"; break;
            default: txt="Mist"; break;
        }
        cout << "Deine Eingabe war: " << txt << ".";
    }
    
    


  • @Zhavok sagte in switch me off!:

    Wie ist es denn nun richtig?

    Meine Güte, wie wäre es mal mit einem Buch über Grundlagen?

    Wenn mindestens eine Seite ein std::string oder std::string_view ist, kannst du mit == vergleichen.
    Wenn du zwei char* (oder char[]) vergleichen möchtest, benötigst du strcmp.



  • Ja. So hab ichs bis jetzt ja auch gehandhabt. So stehts auch in meinem Buch. Deshalb hats mich gewundert. War mir jetzt nur nicht mehr ganz sicher, weil ja nicht alles Gold ist, was in C++ Büchern steht 😉



  • @yahendrik sagte in switch me off!:

    das ist im Französischen natürlich etwas anders - das bekomme ich aber ehrlicherweise nicht mehr auf die Schnelle zusammen).

    Ausnahmen im frz: 11-16 ( ab 17 wieder 10+7 = dix-sept, etc. ).
    Und dann quasi 70 ( 60+10 = soixante-dix ), 80 ( 4 mal 20 = quatre-vingt ), 90 ( 4 mal 20+10 = quatre-vingt-dix )
    😉



  • @It0101 sagte in switch me off!:

    70 ( 60+10 = soixante-dix ), 80 ( 4 mal 20 = quatre-vingt ), 90 ( 4 mal 20+10 = quatre-vingt-dix )

    In CH (und wohl auch in BE) heißt es septante, huitante und nonante 🙂


Anmelden zum Antworten