La Sentencia IR-A XY(gotoxy) : en general, no existe ninguna necesidad de utilizar instrucciones ir-a se puede reescribir para hacer lo mismo

y no incluir ninguna instruccin ira. Cuando se encuentra un error en otra condicin de terminacin la instruccin ir-a puede ser utilizada para saltar directamente al final del bucle. Estructura Repetitiva Mientras: muchas veces se requiere repetir una o varias instrucciones para llevar a cabo una tarea, en la programacin se cuenta con estructuras que permiten realizar este proceso, llamados tambin bucles, iterativas, lazos, entre otros. Dependiendo el lenguaje de programacin, estas incorporan dos o mas estructuras repetitivas, dentro de las cuales las infaltables son mientras (while) y para (for) , con las cuales se puede resolver todo problema que involucre procesos repetitivos. Cuando se trabaja con estas estructuras se utiliza trminos como contadores, acumuladores, forzar la salida del bucle y continuar al inicio del bucle. Contador: Son variables que se incrementan (+) o decrementan (-) con un valor constante, por ejemplo una variable C cuyo valor se incrementa de 1 en 1, se conoce como variable contador. Pseudocdigo C++ CC+1 C=C+1 ii+2 i+=2 Jj1 j --

Acumulador: Son variables de cualquier tipo que almacenan valores variables, por ejemplo la variable C cuyo valor se incrementa por el valor que va tomando otra variable llamada X. Pseudocdigo C++ CC+X C=C+X ii+C i+=C Jji j-=i Salir del bucle: Es una instruccin que permite forzar la salida de un bucle, para esto los lenguajes de programacin incorporan una instruccin que permita realizar dicha operacin. Pseudocdigo C++ Salir break Continuar al inicio del bucle: Es una instruccin que permite saltar al inicio del bucle para volver a ejecutarse, para esto los lenguajes de programacin incorporan una instruccin que permita realizar dicha operacin. Pseudocdigo C++ Continuar continue

La estructura repetitiva mientras , permite repetir una o mas instrucciones hasta que la condicin (expresin lgica) sea verdadera, cuando la condicin es falsa sale del bucle. While (expresin) { . . .} (entrada controlada), While (expresin) (sea verdadera) { ---------------------------------Bloque de instrucciones ------------------

} Mientras (expresin sea verdadera) Inicio --------------------Fin

Esta sentencia permite ejecutar repetidamente, mientras se cumpla una determinada condicin, una sentencia o bloque de sentencias. La forma general es como sigue: while ( expresion_de_control ) sentencia Explicacin: Se evala la expresin_de_control y si el resultado es false (falso) se salta sentencia y se prosigue la ejecucin. Si el resultado es true (verdadero) se ejecuta sentencia y se vuelve a evaluar expresin_de_control (evidentemente alguna variable de las que intervienen en expresin_de_control habr tenido que ser modificada, pues si no el bucle continuara indefinidamente). La ejecucin de sentencia prosigue hasta que expresin_de_control se hace false (falso), en cuyo caso la ejecucin continua en la lnea siguiente. En otras palabras, sentencia se ejecuta repetidamente mientras expresin_de_control sea true (verdadera), y se deja de ejecutar cuando expresin_de_control se hace false (falso). Obsrvese que en este caso el control para decidir si se sale o no del bucle esta antes de sentencia, por lo que es posible que sentencia no se llegue a ejecutar ni una sola vez.

Ejm: a = 10; while (a > 0) { cout<< a << endl; a -- ; }

Ejm: b = 13; c=7 while (b > 0 && c < 10) { cout<< b << << c <<endl; b -- ; c ++; }

La estructura repetitiva mientras anidada, dentro de la estructura es posible Colocar una o mas estructuras repetitivas as como otras estructuras. Sintaxis C++ while (<expresin lgica>) { while (<expresin lgica>) { <instruccin 1> <instruccin n> } } pseudocdigo mientras expresin lgica mientras expresin lgica <instruccin 1> <instruccin n> fin mientras fin mientras

Realizar un programa para convertir un numero de base 10 a base 2 y hexadecimal. # include <iostream.h> # include <conio.h> void main (void) { int num, base, resto, x=40; clrscr(); cout<<ingrese un numero: ; cin>>num; cout<<ingrese la base: ; cin>>base; while ( num > 0) { resto = num % base; num = num / base; gotoxy (x, 10); switch(resto) { case 10 : cout<<A; break; default: cout<<resto; } x--; } getch(); }

La estructura repetitiva ( hacermientras) Do {. . . } While (expresin) { Si entrada controlada Sintaxis C++ Do { bloque de instruccin } while (<expresin lgica>) pseudocdigo hacer inicio bloque de instruccin fin mientras (expresin es verdadera)

1.- Ejm: a = 0; b = 0; do { a + = 2; b - = 2; cout<<a<< <<b<<endl; } while ( a < 15) VVF cout<<a<< <<b<<endl; a 10 12 14 16 b 0 -2 -4 -6 a 12 14 16 16 b -2 -4 -6 -6

2.- Ejm: a = 3; b = 0; do { a - = 2; b + = 2; cout<<a<< <<b<<endl; } || while ( a > 0 && b<5) VF VV cout<<a<< <<b<<endl; a 3 1 -1 -3 b 0 2 4 6 a 1 -1 -3 b 2 4 6

Do {

cout<<desea continuar S/N \n; tecla = toupper (getch()); } while (tecla ! = S && tecla != N); -----------------------------------------------------------------------------------------------------------------Do { cout<<ingrese un numero \n; cin>>n; } while (N >= 0);
. El ejemplo muestra el uso de do while para controlar el ingreso de nmeros por el teclado. El programa repetir que ingrese un numero mientras este sea un numero positivo. 1.- Realizar un programa que muestre los n trminos de la serie de Fibonacci. Antepenltimo Ultimo Siguiente 0 1 2 3 4 5 6

Antepenltimo Ultimo Siguiente 0 1 1 2 3 5 8 13 . . . N A + B C A + B = C A + B = C A + B = C A + B = C A + B = C A=0 B=1 C = A + B //1 A=B B=C C = A +B

# include <iostream.h> void main (void) { int n, a, b, c; clrscr(); cout<<ingrese nmeros de trminos\n; cin>>n; a=0; b=1; cout<<a<<endl; while ( b < n) { cout<<b<<endl; c= a+b; a=b; b=c; } getch(); }

# include <iostream.h> Long int A, B, C, N, i; void main (void) { do { cout<<ingrese nmeros de trminos\n; cin>>N; } while ( N < = 0) i = 2; A = 1; B = 1; C = A+B; cout<< A << , << B << , ; while ( i < N) { cout<< C << , ; A = B; B = C; C = A+B; i + = 1; } }

Realizar un programa que sume 10 nmeros positivos y muestre el resultado S = 0; ..controla mejor Num Pos = 0; Do { do { cout<<ingrese un numero positivo\n; cin>>N; } while (N<0) S+ = N; Num Pos ++; } while (Num Pos < 10) S = 0; ..hace lo mismo Num Pos = 0; Do { cout<<ingrese un numero positivo\n; cin>>N; if (N>= 0) S+ = N; Num Pos ++; } while (Num Pos < 10)

Estructura Repetir (repeat) do until (repetir-hasta que): se ejecuta hasta que se cumpla una condicion determinada que se comprueba al final del bucle. Repetir repeat do until <condicin> <acciones> <acciones> <acciones> ... Hasta_que <condicin> until <condicin> end do El bucle repetir_hasta_que; se repite mientras el valor de la expresin booleana de la condicin sea falsa, justo la opuesta de la sentencia mientras. Algoritmo repetir el programa se repite hasta que el valor de la Var : numero : real variable contador exceda a 20 contador : entero Inicio contador 1 repetir leer (numero) contador contador + 1 hasta_que contador > 20 escribir (numeros leidos 20) fin

Diferencias entre while y do while : una sentencia do while es similar a una while, excepto que el cuerpo del bucle se ejecuta siempre al menos una vez. Sintaxis SENTENCIA SIMPLE While (expresin_lgica) do sentencia sentencia SENTENCIA COMPUESTA While (expresin_lgica) do { sentencia-1 { sentencia-1 sentencia-2 sentencia-2 ... ... sentencia-n sentencia-n } } while (expresin_lgica) 1.- int x=0; do cout<<x : <<x+1; while (x<10) 2.- char letra = a; do { cout<< letra << ; letra++; } while (letra <=z)

 Visualizar las potencias de 2 cuerpos cuyos valores estn en el rango de 1---1000 // while //do while potencia=1; potencia=1; while (potencia<1000) do { cout<<potencia<<endl; { cout<<potencia<<endl; potencia * = 2; potencia * = 2; } } while (potencia<1000) Diferencias de las estructuras mientras y repetir: La estructura mientras termina cuando la condicin es falsa, mientras que repetir termina cuando la condicin es verdadera. En la estructura repetir el cuerpo del bucle se ejecuta siempre al menos una vez ; por el contario, mientras es mas general y permite la posibilidad de que el bucle pueda no ser ejecutado. Para usar la estructura repetir debe estar seguro de que el cuerpo de bucle bajo cualquier circunstancia se repetir al menos una vez.