ESTRUCTURAS DE CONTROL
Las instrucciones o sentencias se organizan en tres tipos de estructuras de control que sirven para controlar el flujo de la ejecución: secuencia, selección (decisión) y repetición. Hasta este momento sólo se ha utilizado el flujo secuencial. Una sentencia compuesta es un conjunto de sentencias encerradas entre llaves ({ y }) que se utiliza para especificar un flujo secuencial.
{
sentencia ;
sentencia ;
sentencia ;
}
El control fluye de la sentencia1, a la .sentencia2 y así sucesivamente. Sin embargo, existen problemas que requieren etapas con dos o más opciones o alternativas a elegir en función del valor de una condición + o expresión.
LA SENTENCIA if
En C, la estructura de control de selección principal es una sentencia if. La sentencia if tiene dos alternativas o formatos posibles. El formato más sencillo tiene la sintaxis siguiente:
La sentencia i f funciona de la siguiente manera. Cuando se alcanza la sentencia if dentro de un programa, se evalúa la expresión entre paréntesis que viene a continuación de if. Si Expresión es verdadera, se ejecuta Acción; en caso contrario no se ejecuta Acción (en su formato más simple,
Acción es una sentencia simple y en los restantes formatos es una sentencia compuesta). En cualquier caso la ejecución del programa continúa con la siguiente sentencia del programa.
Otro sistema de representar la sentencia i f es:
if (condición) sentencia;
condi ci ón es una expresión entera(lógica).
sentencia es cualquier sentencia ejecutable, que se ejecutará sólo si la condición toma un valor distinto de cero.
Ejemplo:
Prueba de divisibilidad
#include
int main( )
{
int n, d;
printf ( "Introduzca dos enteros: " ) ;
scanf ("%d %d",& n,& d);
if (n%d == O) printf ( " %d es divisible por %d\n",n,d);
return O;
}
nota:
Este programa lee dos números enteros y comprueba cuál es el valor del resto de la división n entre d (n%d). Si el resto es cero, n es divisible por d (en nuestro caso 36 es divisible por 4, ya que 36 : 4 = 9 y el resto es O).
http://www.badongo.com/file/14149018
LA SENTENCIA for:
El bucle for de C es superior a los bucles for de otros lenguajes de programación tales como BASIC, Pascal y Fortran ya que ofrece más control sobre la inicialización y el incremento de las variables de control del bucle.
Además del bucle while, C proporciona otros dos tipos de bucles for y do. El bucle for que se estudia en esta sección es el más adecuado para implementar bucles controlados por contador que son bucles en los que un conjunto de sentencias se ejecutan una vez por cada valor de un rango especificado, de acuerdo al algoritmo:
por cada valor de una variable-contador de un rango especifico: ejecutar sentencias
La sentencia for (bucle for) es un método para ejecutar un bloque de sentencias un número fijo de veces. El bucle for se diferencia del bucle while en que las operaciones de control del bucle se sitúan en un solo sitio.
http://www.badongo.com/file/14149017
SENTENCIA DE CONTROL switch
La sentencia switch es una sentencia C que se utiliza para seleccionar una de entre múltiples alternativas.
La sentencia switch es especialmente Útil cuando la selección se basa en el valor de una variable simple o de una expresión simple denominada expresicín de control o selector. El valor de esta expresión puede ser de tipo int o char, pero no de tipo float ni double.
Sintaxis
switch (selector)
{
case etiqueta, : sentencias,;
case etiqueta, : sentencias,;
case etiqueta, : sentencias,;
default: sentencias,; /* opcional. */
}
La expresión de control o se1 ector se evalúa y se compara con cada una de las etiquetas de case.
La expresión selector debe ser un tipo ordinal (por ejemplo, int , char, pero no float o string ) .
Cada etiqueta es un valor Único, constante y cada etiqueta debe tener un valor diferente de los otros.
Si el valor de la expresión selector es igual a una de las etiquetas case -por ejemplo, etiqueta - entonces la ejecución comenzará con la primera sentencia de la secuencia sentencia y continuará hasta que se encuentra el final de la sentencia de control sw I tch, o hasta encontrar la sentencia break.
Es habitual que después de cada bloque de sentencias correspondiente a una secuencia se desee terminar la ejecución del switch; para ello se sitúa la sentencia break como Última sentencia del bloque.
break hace que siga la ejecución en la siguiente sentencia ai switch.
http://www.badongo.com/file/14149020
ESTRUCTURAS DE CONTROL:
BUCLES
LA SENTENCIA while
Estructura Mientras (While)Al igual que el bucle for, el bucle While es un bucle de precondición. Esto significa que el programa evalúa la condición antes de entrar en la instrucción o instrucciones del cuerpo del bucle. Como consecuencia de esto, los bucles de precondición se pueden ejecutar desde cero hasta varias veces.La sentencia while se utiliza para generar bucles repetidamente, hasta que la condición deje de ser verdadera.Sintaxis:while ( [condición] ) {Sentencias;}Como en todas las estructuras que hemos visto, si se cuenta con una sola sentencia de repetición, no es necesario escribir las llaves.
http://www.badongo.com/file/14149021
La sentencia do – while se utiliza para especificar un bucle condicional que se ejecuta al menos una vez. Esta situación se suele dar en algunas circunstancias en las que se ha de tener la seguridad de que una determinada acción se ejecutará una o varias veces, pero al menos una vez.Cuando se construye un bucle usando while, la evaluación de la condición para la continuación del bucle se realiza al comienzo de cada pasada. Sin embargo, a veces es deseable disponer de un bucle en el que se realice el examen al final de cada pasada.Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle.La única diferencia entre las sentencias while y do-while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez.
http://www.badongo.com/file/14149016
APUNTADORES
¿Qué es un apuntador?
Un apuntador es un objeto que apunta a otro objeto. Es decir, una variable cuyo valor es la dirección de memoria de otra variable.
No hay que confundir una dirección de memoria con el contenido de esa dirección de memoria.
Las direcciones de memoria dependen de la arquitectura de la computadora y de la gestión que
el sistema operativo haga de ella.
En C no debemos, ni podemos, indicar numéricamente la dirección de memoria, si no que utilizamos una etiqueta que conocemos como variable (las variables tienen asociada una dirección de memoria).
Lo que nos interesa es almacenar un dato, y no la localización exacta de ese datoen memoria.
Una variable apuntador se declara como todas las variables. Debe ser del mismo tipo que la variable apuntada.
Su identificador va precedido de un asterisco (*):
int *punt;
Es una variable apuntador que apunta a variable que contiene un dato de tipo entero llamada punt.
char *car:
Es un apuntador a variable de tipo carácter.
Un apuntador tiene su propia dirección de memoria:
&punt
Es decir: hay tantos tipos de APUNTADORES como tipos de datos, aunque también pueden declararse APUNTADORES a estructuras más complejas (funciones, struct, objetos (instancias de una clase), ficheros e incluso APUNTADORES vacíos (void) y APUNTADORES nulos (NULL).
Declaración de variables apuntador: Sea un fragmento de programa en C:
char dato; //variable que almacenará un carácter.
char *punt; //declaración de puntador a carácter.
punt = &dato; //en la variable punt guardamos la dirección de memoria
// de la variable dato; punt apunta a dato. Ambas son del mismo tipo, char.
Operadores Específicos:
--> Operador de dirección: & Representa la dirección de memoria de la variable que le sigue:
&fnum representa la dirección de fnum.
--> Operador de contenido o in dirección: *. El operador * aplicado al nombre de un apuntador
indica el valor de la variable apuntada.
Aritmética de APUNTADORES:
A una variable apuntador se le puede asignar la dirección de cualquier objeto.
- A una variable apuntador se le puede asignar la dirección de otra variable apuntador (siempre que las dos señalen el mismo objeto)
- A un apuntador se le puede inicializar con el valor NULL
- Una variable apuntador puede ser restada o comparada con otra si ambas apuntan a elementos de un mismo arreglo.
- Se puede sumar o restar valores enteros: p++, pv+3, teniendo en cuenta que el desplazamiento (offset) depende del tipo de dato apuntado:
p++; //p apunta a la siguiente dirección
pv+=3 //pv apunta 3*n bytes del dato apuntado (offset)
APUNTADORES a ARREGLOS:
Un arreglo multidimensional es, en realidad, una colección de vectores. Según esto, podemos
definir un arreglo bidimensional como un apuntador a un grupo contiguo de arreglos unidimensionales.
Las declaraciones siguientes son equivalentes:
int dat[fil][col] int (*dat)[col]
APUNTADORES a cadenas de caracteres:
Una cadena de caracteres es un arreglo de caracteres. La forma de definir un apuntador a una
cadena de caracteres:
char *cadena;
El identificador del arreglo es la dirección de comienzo del arreglo. Para saber dónde termina la
cadena, el compilador añade el carácter ‘\0’ (ASCII 0, NULL):
char *nombre = “PEPE PEREZ”;
APUNTADORES a funciones:
Una función ocupa una posición física en la memoria, por lo que se puede referenciar por medio de una dirección, por ello se puede usar un apuntador a una función como argumento de llamado a otras funciones. Para comprender este concepto, se tiene que entender los pasos
que sigue el compilador y como se hace el llamado de funciones en C. El primer paso de lo que llamamos compilador, es el de traducir el programa escrito en lenguaje C a un programa escrito en lenguaje de maquina. El segundo paso, es el de sustituir los llamados de las funciones por las direcciones donde empieza cada función.
En lenguaje C se obtiene la dirección de la función utilizando el nombre de la función sin paréntesis y sin argumentos, como si se tratara de una variable de tipo arreglo, como cuando se utiliza solo el nombre del arreglo, sin índices.
-->APUNTADORES constantes:
Una declaración de apuntador precedida de const hace que el objeto apuntado sea una constante (aunque no el apuntador):
const char *p = “La Paz”;
p[0] = ‘f’ //error. La cadena apuntada por p es constante.
p = “Púlsela” //OK. p apunta a otra cadena.
Si lo que queremos es declarar un apuntador constante;
char *const p = “Aguilar”;
p[0] = ‘s’; //error: el objeto “Aguilar”, es cte.
p = “Peñafiel”; //error: el apuntador p es constante.
Las dos formas que siguen son análogas; en ambos casos representan puntero-a-tipoX-constante (el objeto al que se apunta es constante), abreviadamente: puntero-a-constante. Se utilizan para avisar al compilador que el objeto referenciado no puede ser modificado, ni aún a través de su puntero.
tipoX const * puntero ... ;const tipoX * puntero ... ;
Ejemplo:
int const * xPtr = &x;const int * yPtr = &y;
xPtr e yPtr son dos objetos del mismo tipo (puntero-a-int constante). Ambos señalan a sendos enteros cuyo Rvalue no pueden ser modificado, sin embargo, los punteros si pueden ser modificados. Por ejemplo, señalando a un nuevo objeto (siempre naturalmente que este sea un int constante).
Los punteros-a-constante son de utilización más frecuente que los punteros constantes (ver a continuación). Se utilizan principalmente cuando se pasan punteros a funciones, porque se desea aligerar la secuencia de llamada .En especial si los punteros señalan a objetos muy grandes y se desea evitar que la función invocada pueda modificar el objeto en cuestión.
La expresión que sigue significa puntero-constante-a-tipoX (el puntero es constante), abreviadamente: puntero constante. Se utiliza para informar al compilador que el valor del puntero no puede cambiar, aunque el objeto al que apunta si pueda cambiar (si no es constante).
tipoX * const puntero ... ;
Puesto que en este tipo de sentencias el puntero es declarado constante y su valor no puede ser modificado con posterioridad, hay que establecer su valor en el mismo momento de la declaración. Es decir, debe ser una definición del tipo:
tipoX * const puntero = dirección de objeto.
Como resumen podemos afirmar que:
Un puntero constante no puede ser modificado
Un puntero-a-constante apunta a un objeto cuyo Rvalue no puede cambiar
-->APUNTADORES a APUNTADORES:
int **apuntador; //apuntador a apuntador a un objeto int.
El tipo de objeto apuntado después de una doble indirección puede ser de cualquier clase.
Permite manejar arreglos de múltiples dimensiones con notaciones del tipo ***mat, de múltiple indirección que pueden generar problemas si el tratamiento no es el adecuado.
Aca unos links donde se puede apreciar un poco más acerca de lo hecho en clases de Programación I(UNIVALLE) :
http://www.badongo.com/file/14148795
http://www.badongo.com/file/14148796
http://www.badongo.com/file/14148797
Esperamos que sea de su agrado nuestro pequeño aporte a la programación!!!!
GRACIAS INGE ARTURO T.!!!!!
Atte. Tatiana Aguilar H.
Douglas Chacón C.
Fabricio Peredo
Andrea Salas
