Tipos de Estructuras Iterativa 1- La Estructura de Repetición for Esta estructura de repetición es más utilizada cuando sabemos el número de repeticiones que deseamos ejecutar. La notación de esta estructura es sencilla y se detalla a continuación for ( condición de inicio ; expresión ; acción después de cada iteración ) { sentencia (s); } La condición de inicio quiere decir que podemos inicializar una variable que vayamos a utilizar dentro el cuerpo de la estructura for. La expresión nos indica que se seguirá iterando(repitiendo) mientras la condición sea verdadera. La acción después de cada iteración viene a ser lo que queremos hacer variar después de cada iteración, esta variación podría ser un incremento en la variable definida en la condición de inicio. Al igual que las demás estructuras de control el cuerpo de la estructura for lleva llaves si este contiene más de una sentencia o instrucción. Ejemplo 6.1 Un ejemplo sencillo puede ser que quiero cantar 10 veces la canción del elefante, el código sería algo así: #include using namespace std; void main() { int i; for( i = 1 ; i<=10 ; i++) { cout<
El código anterior emitirá por pantalla 10 veces el mensaje de 1 elefante ....... hasta 10 elefantes...... El ejemplo anterior es muy sencillo pero nos muestra el funcionamiento de la estructura for. * Practica los problemandos 37 al 49
2- Estructura de repetición do while Esta estructura de control es muy parecida a la estructura while lo que la hace diferente es que siempre ejecuta por lo menos una ves el cuerpo de la estructura, por eso el do, y luego valida una expresión y en función a este resultado vuelve a iterar o no. La notación de esta estructura es como sigue: do { sentencias o instrucciones } while ( expresión ); Las estructura do/while lleva punto y coma a diferencia de la estructura while. w hile.
Ejemplo 6.2
Un ejemplo para este caso es el siguiente: Se desea ingresar por lo menos un nombre de un estudiante por teclado hasta que el usuario presione '0' para salir o cualquier otro número para continuar. #include using namespace std; void main() { char nom[20]; //Cadena que puede contener 20 caracteres int rpta=0; do { cout<<"Ingrese el nombre de un estudiante \n"; cin>>nom; cout<<"Desea continuar ingresando nombres: para salir '0'"; cin>>rpta; } while(rpta != 0); }
* Practica los problemandos 50 y 51
3- Estructura de repetición while Dicha estructura repite una serie de acciones mientras se cumpla una condición. while ( expresión ) { sentencia (s); } La estructura while trabaja de la siguiente manera:
1. Evalúa la expresión o condición 2. Si el resultado de esta evaluación es verdadero la sentencia o sentencias se ejecutan, es decir, se ejecuta el cuerpo de la estructura. Luego se vuelve a evaluar la expresión 3. Si el resultado de esta evaluación es falso no se ejecuta la sentencia o sentencias y sale del ciclo while. Por ejemplo tengo que apagar 10 velas cuando cumpla 10 años, es decir, tengo que soplar 10 veces, entonces el problema escrito en Pseudocódigo sería: Inicio edad <- 0 mientras edad != 10 años soplar vela edad = edad + 1 Fin Mientras Fin Ejemplo 6.3 Otro ejemplo que nos demostrará iteraciones con límite conocido es: Tengo que mostrar la tabla de multiplicar del 9 por pantalla #include using namespace std; void main() { int nro=1;
while(nro <= 10 ) { cout<<"9 * "< using namespace std; void main() { int nro=0, aux=0, rpta=0; cout<<"Ingrese un numero entero"; cin>>nro; while(nro > 0) { aux = nro % 10; nro = nro / 10; rpta = (rpta * 10) + aux; } cout<<"El numero invertido es: "<
Las funciones se declaran y se definen exactamente igual que en C, y, al igual que en éste, se puede utilizar prototipo (prototype). Un prototipo es un modelo limitado de una entidad más completa que aparecerá después. En el caso de funciones, la función es la entidad completa que vendrá después, y la declaración de dicha función es el prototipo. El prototipo da un modelo de la interface a la función. Veamos un ejemplo: # include void do_stuff (int wings, float feet, char eyes); main() { int arm = 2; float foot = 1000.0; char lookers = 2;
do_stuff (3, 12.0, 4); do_stuff (arm, foot, lookers); } void do_stuff (int wings, float feet, char eyes) { cout << "There are " << wings << "wings." << '\n'; cout << "There are " << feet << "feet. " << '\n'; cout << "There are " << int(eyes) << "eyes." << '\n'; } La salida de este programa será: There are 3 wings. There are 12 feet. There are 4 eyes. There are 2 wings. There are 1000 feet. There are 2 eyes. Cada llamada a la función do_stuff() debe verificar: •
•
El número de parámetros debe ser exactamente tres. Los tipos deben ser compatibles con los de la declaración (más adelante explicaremos qué son tipos compatibles).
Nótese que cuando llamamos a la función, la comprobación de tipo la hace el compilador basándose en el prototipo (en la declaración) puesto que la función todavía no ha sido definida. Los nombres de variables que aparecen en el prototipo son opcionales y actúan casi como comentarios al lector del programa, ya que son completamente ignorados por el compilador. Tipos compatibles
Son compatibles cualquiera de los tipos simples (definidos en C++) que pueden ser convertidos de uno a otro de manera significativa. Por ejemplo, si llamamos con un entero a una función que está esperando un número real como parámetro, el sistema lo convertirá automáticamente, sin mencionarlo al usuario. Esto también es cierto de float a char, o de char a int. En cambio, si pasamos un puntero a un entero a una función que estaba esperando un entero, no habrá conversión de tipo, ya que son dos variables completamente distintas. De la misma forma, un tipo definido por el usuario (estructura o clase) no puede ser convertido automáticamente a un long float, a un array o incluso a otra estructura o clase diferente, porque son tipos incompatibles y no puede realizarse la conversión de manera significativa. Sin embargo, el tipo devuelto por la función, void en el ejemplo anterior, debe ser compatible con el tipo que se espera que devuelva en la función de llamada, o el compilador dará un warning. Pequeños cambios
Volvamos al ejemplo anterior. Veamos qué sucede cuando hacemos pequeños cambios: •
Llamamos a la función con do_stuff (12.2, 13, 12345). No se produce ningún error durante la compilación, pues estamos trabajando con tipos compatibles. La salida del programa es: There are 12 wings. There are 13 feet. There are 57 eyes. There are 2 wings. There are 1000 feet. There are 2 eyes.
•
•
•
Llamamos a la función con sólo dos parámetros: do_stuff (12.2, 13). El compilador lanzará un mensaje de error: 11:error: In this statement, "do_stuff(1.22e1, 13)" supplies 2 arguments, but 3 are expected. En la segunda llamada a la función, ponemos un & delante del nombre de una de las variables, do_stuff (arm, &float, lookers). El mensaje de error es el siguiente: 13:error:In this statement, "&lookers" is of type "pointer to char", and may not be converted to "char". Cambiemos, en el prototipo, void por int, int do_stuff(int wings, float feet, char eyes);. Entonces, al compilar:
16:error:In this declaration, the type of "do_stuff" is not compatible with the type of previous declaration of "do_stuff". Si ahora modificamos además el tipo devuelto en la declaración de la función, int do_stuff (int wings, float feet, char eyes) { ...}, obtenemos: 16:warning:Non-void function "do_stuff" does not contain a return statement. •
Podemos cambiar la declaración de la función por: void do_stuff (int, float, char); Esto no dará ninguna diferencia respecto al programa original. Esto demuestra que los nombres de las variables en el prototipo son tratados como comentarios por el compilador de C++.
•
La función podría haber sido declarada de la siguiente forma: void do_stuff (int wings, //Number of wings float feet, //Number of feet char eyes, //Number of eyes Esto hace que la cabecera de la función sea autoexplicatoria. Sin embargo, debe recordarse que los comentarios nunca deben usarse en lugar de nombres significativos para las variables.
El uso de prototipos no supone coste alguno en tiempo ni en velocidad de ejecución. El prototipo se verifica durante la compilación. Ralentiza ésta, debido a que es una comprobación extra que el compilador debe hacer, pero es despreciable el tiempo que necesita. El prototipo sólo alarga el tamaño del código.