c++ - sentencia - tipos de decisiones en programacion

¿Sentencia de conmutación avanzada dentro del ciclo while?

Question

Acabo de iniciar C ++, pero tengo un conocimiento previo de otros lenguajes (vb un tiempo atrás, lamentablemente), pero tengo una situación extraña. No me gustaba usar tantas declaraciones IF y quería usar switch / cases porque parecía más limpio, y quería entrar en la práctica ... Pero ...

Digamos que tengo el siguiente escenario (código teórico):

while(1) {

  //Loop can be conditional or 1, I use it alot, for example in my game
  char something;
  std::cout << "Enter something/n -->";
  std::cin  >> something;

  //Switch to read "something"
  switch(something) {
    case ''a'':
      cout << "You entered A, which is correct";
      break;
    case ''b'':
      cout << "...";
      break;
  }
}

Y ese es mi problema Digamos que quería salir del ciclo WHILE, ¿se necesitarían dos declaraciones de interrupción?

Obviamente, esto parece incorrecto:

case ''a'':
  cout << "You entered A, which is correct";
  break;
  break;

Entonces, ¿solo puedo hacer una declaración IF en la ''a'' para usar break? ¿Me estoy perdiendo algo realmente simple?

Esto resolvería muchos de mis problemas que tengo ahora.

Answer 1

Dos declaraciones de break no lo sacarán del ciclo while. El primer break solo lo saca de la declaración de switch y nunca se alcanza el segundo.

Lo que necesita es hacer que la condición del bucle while sea falsa, suponiendo que no hay nada en el bucle después de la instrucción switch . Si hay otro código después del cambio, debe verificar la condición después del switch y break allí.

bool done = false;

while(! done)
{
  // do stuff
  switch(something)
  {
    case ''a'':
    done = true;  // exit the loop 
    break;
  }

  //  do this if you have other code besides the switch
  if(done)
   break;  // gets you out of the while loop

  // do whatever needs to be done after the switch

}

Answer 2

Podrías reemplazar el interruptor con una solución OO ligeramente sobrediseñada ...

#include <iostream>
#include <map>
#include <set>

class input_responder
{
    std::set<char> correct_inputs;
    std::map<char, const char*> wrong_inputs;

public:

    input_responder()
    {
        correct_inputs.insert(''a'');
        wrong_inputs[''b''] = "...";
    }

    bool respond(char input) const
    {
        if (correct_inputs.find(input) != correct_inputs.end())
        {
            std::cout << "You entered " << input << ", which is correct/n";
            return true;
        }
        else
        {
            std::map<char, const char*>::const_iterator it = wrong_inputs.find(input);
            if (it != wrong_inputs.end())
            {
                std::cout << it->second << ''/n'';
            }
            else
            {
                std::cout << "You entered " << input << ", which is wrong/n";
            }
            return false;
        }
    }
};

int main()
{
    const input_responder responder;
    char input;
    do
    {
        std::cout << "Enter something/n -->";
        std::cin  >> input;
    } while (responder.respond(input) == false);
}

Answer 3

Puedes cambiar tu interruptor a un sistema if. Se compilará a la misma cosa de todos modos.

Answer 4

Refactorizaría el cheque a otra función.

bool is_correct_answer(char input)
{
    switch(input)
    {
    case ''a'':
        cout << "You entered A, which is correct";
        return true;
    case ''b'':
        cout << "...";
        return false;
    }
    return false;
}

int main()
{
    char input;
    do
    {
        std::cout << "Enter something/n -->";
        std::cin  >> input;
    } while (!is_correct_answer(input));
}

Answer 5

Sí, C y C ++ no tienen forma de decir "salir de múltiples bloques rompibles" (donde un "bloque rompible" es cualquier bucle o interruptor). Las soluciones incluyen goto s y el uso de variables booleanas para registrar si un "bloque rompible" externo también debería romperse (ninguno de los dos es elegante, pero así es la vida).

Answer 6

Simplemente podría tener la verificación while loop para un valor bool que se establece dentro de una de las declaraciones de su caso.

bool done = false;    
while(!done)
{
 char something;
  std::cout << "Enter something/n -->";
  std::cin  >> something;

  //Switch to read "something"
  switch(something) {
    case ''a'':
      cout << "You entered A, which is correct";
      done = true; // exit condition here
      break;
    case ''b'':
      cout << "...";
      break;
  }
}

Answer 7

También puede encapsular el bucle en una función y devolver llamada dentro de la caja, en el caso de que la bandera no sea suficiente. No es una buena práctica de programación para algunas personas, pero si mantienes la función simple, no veo por qué no.

Answer 8

Tu podrías intentar:

• Usando banderas
• Usando Goto
• Tener el bloque Inner Breakable en una función
• Usando Excepciones
• Usando longjump y setjmp

Un tema muy similar a esta pregunta

http://www.gamedev.net/community/forums/topic.asp?topic_id=385116

Answer 9

Puede que le interese el modismo del loop nombrado en C ++.

#define named(blockname) goto blockname; /
                         blockname##_skip: if (0) /
                         blockname:

#define break(blockname) goto blockname##_skip;

named(outer)
while(1) {

  //Loop can be conditional or 1, I use it alot, for example in my game
  char something;
  std::cout << "Enter something/n -->";
  std::cin  >> something;

  //Switch to read "something"
  switch(something) {
    case ''a'':
      cout << "You entered A, which is correct";
      break(outer);
    case ''b'':
      cout << "...";
      break(outer);
  }
}