how to exit nested loops

Question

i have something like

   while(playAgain==true)
   {
      cout<<\"new game\"<

        

Answer 1

Use goto:

   while(playAgain==true)
   {
      cout<<"new game"<<endl; //i know 'using namespace std;' is looked down upon
      while(playerCard!=21)
      {
          *statements*
          if(decision=='n')
          {
              goto label;
          }
       ...
      }
   }
   label: 
   ...    

Answer 2

If you don't have to avoid goto statement, you can write

while (a) {
    while (b) {
        if (c) {
            goto LABEL;
        }
    }
}
LABEL:

Answer 3

There are basically two options to go.

1. Add the condition check in outer loop.

   while ((playAgain==true) && (decision != '\n'))

2. Simply use goto. People are often told never to use goto as if it's monster. But I'm not opposed to use it to exit multiple loops. It's clean and clear in this situation.

Answer 4

This solution is specific to your case. When the user's decision is 'n', he doesn't want to play again. So just set playAgain to false and then break. Outer loop will be broken automatically.

while(playAgain==true){
   cout<<"new game"<<endl; //i know 'using namespace std;' is looked down upon
   while(playerCard!=21){
      *statements*
      if(decision=='n'){
         playAgain = false; // Set this to false, your outer loop will break automatically
         break;
      }
   }
}

Answer 5

 while(playAgain==true && decision !='n' ){
                           ^^ add a condition
      cout<<"new game"<<endl; 
      while(playerCard!=21){
      *statements*
      if(decision=='n'){
          break
         }
     ...
      }
 }

Answer 6

Don't cook spaghetti and extract your loops into the function:

void foo(...) {
    while (...) {
        /* some code... */
        while (...) {
            if ( /* this loop should stop */ )
                break;
            if ( /* both loops should stop */ )
                return;
        }
        /* more code... */
    }
}

this decomposition will also yield cleaner code since instead of hundreds of lines of ugly procedural code, you will have neat functions at different levels of abstraction.