Destabilizar el codigo?
Esa afirmacion es bastante confusa.
Si con codigo estable se refiere a codigo que produce ejecutables estables... entonces goto no seria un problema alli siemper y cuando la ejecutable sea estable.
Ahora, si tienes algo asi:
if(blablabla())
goto ALGUN_LUGAR_MUY_LEJANO_DE_AQUI;
/*
5.000 lineas de codigo mas abajo:
ALGUN_LUGAR_MUY_LEJANO_DE_AQUI:
Eso si seria molesto. Extremadamente molesto. Muy extremadamente molesto. Demasiado extremadamente molesto.
Si el goto salta 2,3 lineas... para que? Si con sentencias de control tranquilamente se puede generar el mismo resultado.
No se me ocurre ningun caso donde un goto sea util. Es mas te digo, cuando se programa en ensamblador normalmente se utilizan saltos condicionales: jz, jnz, je, jne, etc... Tranquilamente se puede programar evitando usar un salto incondicional (JMP) que seria el goto.
Es mas, el programa que usa goto esta desperdiciando bytes...
si pones algo como:
estarias haciendo algo asi:
call algo
test eax, eax
jnz NEXT:
JMP ALGO
NEXT:
;salida next
Mientras sin el goto, seria simplemente:
seria algo como
call algo
test eax, eax
jnz NEXT
call algo2
NEXT:
un JMP innecesario menos y no hay que volver a la prehistoria.
ya que puede darse el caso que instrucciones nunca se lleguen a ejecutar
eso no seria culpa del goto.
if(1==2){
codigo_que_nunca_se_va_a_ejecutar();
}
Saludos.
PD: una consulta...
Que pasa con C++, destructores y goto?
{
MYCLASS my_class; //se llamo al constructor
goto AVOID_DESTRUCTOR
} //<< aqui la runtime llamaria al destructor del objeto my_class
AVOID_DESTRUCTOR:
O sea, lo entiendo bien? al usar un goto y salirse del scope, el destructor nunca seria llamado?
Acabo de hacer la prueba y el destructor es llamado... raro?
#include <iostream>
using namespace std;
class CClass {
public:
~CClass(){
cout << "destructor" << endl;;
}
CClass(){
cout << "constructor" << endl;
}
};
int main(int argc, char *argv[]) {
{
CClass test;
goto AVOID;
}
AVOID:
int i;
cin >> i;
return 0;
}