¿Esto justifica las declaraciones de goto?

Me encontré con esta pregunta hace un segundo, y estoy sacando parte del material de allí: ¿Hay un nombre para la construcción 'break n'?

Esto parece ser una forma innecesariamente compleja para que las personas tengan que instruir al programa para que salga de un bucle doble anidado:

for (i = 0; i < 10; i++) {
    bool broken = false;
    for (j = 10; j > 0; j--) {
        if (j == i) {
            broken = true;
            break;
        }
    }
    if (broken)
        break;
}

Sé que a los libros de texto les gusta decir que las declaraciones de goto son el demonio, y no me gustan en absoluto, pero ¿justifica esto una excepción a la regla?

Estoy buscando respuestas que traten con n-nested para bucles.

NOTA: Ya sea que responda sí, no o en algún punto intermedio, las respuestas completamente cerradas no son bienvenidas. Especialmente si la respuesta es no, proporcione una razón buena y legítima (que de todos modos no está demasiado lejos de las regulaciones de Stack Exchange).

La aparente necesidad de una declaración ir surge de que usted elija expresiones condicionales pobres para los bucles .

Usted declara que desea que el ciclo externo continúe tanto tiempo i < 10y que el más interno continúe tanto tiempo j > 0.

Pero en realidad eso no es lo que quería , simplemente no le dijo a los bucles la condición real que quería que evaluaran, luego desea resolverlo usando break o goto.

Si le dice a los bucles sus verdaderas intenciones para comenzar , entonces no necesita descansos ni goto.

bool alsoThis = true;
for (i = 0; i < 10 && alsoThis; i++)
{    
    for (j = 10; j > 0 && alsoThis; j--)
    {
        if (j == i)
        {
            alsoThis = false;
        }
    }
}

En este caso, podría refactorizar el código en una rutina separada y luego solo returndesde el bucle interno. Eso negaría la necesidad de salir del bucle externo:

bool isBroken() {
    for (i = 0; i < 10; i++)
        for (j = 10; j > 0; j--)
            if (j == i) return true;

    return false;
}

No, no creo que gotosea ​​necesario. Si lo escribes así:

bool broken = false;
saved_i = 0;
for (i = 0; i < 10 && !broken; i++)
{
    broken = false;
    for (j = 10; j > 0 && !broken; j--)
    {
        if (j == i)
        {
            broken = true;
            saved_i = i;
        }
    }
}

Tener &&!brokenambos bucles te permite salir de ambos cuando i==j.

Para mí, este enfoque es preferible. Las condiciones del bucle son extremadamente claro: i<10 && !broken.

Una versión de trabajo se puede ver aquí: http://rextester.com/KFMH48414

Código:

public static void main(String args[])
{
    int i=0;
    int j=0;
    boolean broken = false;
    for (i = 0; i < 10 && !broken; i++)
    {
        broken = false;
        for (j = 10; j > 0 && !broken; j--)
        {
            if (j == i)
            {
                broken = true;
                System.out.println("loop breaks when i==j=="+i);
            }
        }
    }
    System.out.println(i);
    System.out.println(j);
}

Salida:

el bucle se rompe cuando i == j == 1
2
0 0

La respuesta corta es "depende". Recomiendo elegir con respecto a la legibilidad y la comprensibilidad de su código. La forma de ir a Goto podría ser más legible que modificar la condición, o viceversa. También puede tener en cuenta el principio de menor sorpresa, la guía utilizada en la tienda / proyecto y la coherencia de la base del código. Por ejemplo, goto para dejar el interruptor o para el manejo de errores es una práctica común en la base del código del kernel de Linux. También tenga en cuenta que algunos programadores pueden tener problemas para leer su código (ya sea planteado con el mantra "goto is evil", o simplemente no lo aprendieron porque su maestro lo cree) y algunos de ellos podrían incluso "juzgarlo".

En términos generales, un goto que va más allá en la misma función a menudo es aceptable, especialmente si el salto no es demasiado largo. Su caso de uso de dejar un bucle anidado es uno de los ejemplos conocidos de goto "no tan malvado".

En su caso, goto es una mejora suficiente que parece tentador, pero no es tanto una mejora que vale la pena romper la regla contra el uso de ellos en su base de código.

Piense en su futuro revisor: tendrá que pensar: "¿Es esta persona un mal programador o de hecho es un caso en el que valió la pena el goto? Permítanme tomar 5 minutos para decidir esto por mí mismo o investigarlo en el Internet." ¿Por qué demonios le harías eso a tu futuro codificador cuando no puedes usar goto por completo?

En general, esta mentalidad se aplica a todo el código "malo" e incluso lo define: si funciona ahora, y es bueno en este caso, pero crea un esfuerzo para verificar que sea correcto, lo que en esta era un goto siempre hará, entonces no hazlo.

Dicho esto, sí, usted produjo uno de los casos un poco más espinosos. Puedes:

• use estructuras de control más complejas, como una bandera booleana, para romper ambos bucles
• ponga su bucle interno dentro de su propia rutina (probablemente ideal)
• ponga ambos bucles en una rutina y regrese en lugar de romper

Es muy difícil para mí crear un caso en el que un doble bucle no sea tan cohesivo que de todos modos no debería ser su propia rutina.

Por cierto, la mejor discusión sobre esto que he visto es el Código completo de Steve McConnell . Si te gusta pensar críticamente en estos problemas, te recomiendo leer, incluso de principio a fin a pesar de su inmensidad.

TLD; DR: No en específico, sí en general

Para el ejemplo específico que usó, diría que no por las mismas razones que muchos otros han señalado. Puede refactorizar fácilmente el código en una forma equivalentemente buena que elimine la necesidad de goto.

En general, la proscripción contra gotoes una generalidad basada en la naturaleza entendida gotoy el costo de usarla. Parte de la ingeniería de software es tomar decisiones de implementación. La justificación de esas decisiones se produce comparando el costo con los beneficios y cada vez que los beneficios superan el costo, la implementación está justificada. La controversia surge debido a diferentes valoraciones, tanto de costo como de beneficio.

El punto es que siempre habrá excepciones donde a gotoestá justificado, pero solo para algunos debido a diferentes valoraciones. La pena es que muchos ingenieros simplemente excluyen las técnicas en ignorancia intencional porque lo leen en Internet en lugar de tomarse el tiempo para entender por qué.

No creo que este caso justifique una excepción, ya que esto se puede escribir como:

def outerLoop(){
    for (i = 0; i < 10; i++) {
        if( broken?(i) )
          return; // broken
    }
}

def broken?(i){
   for (j = 10; j > 0; j--) {
        if (j == i) {
            return true; // broken
        }
   }
   return false; // not broken
}