1

Programación en C/C++

Lauren MontenegroLaboratorio de Programación I

Docente: Elsner González

2

IndicePORTADA .........................................................................................................................1INDICE...............................................................................................................2INTRODUCCIÓN A C............................................................................................4

UN PROGRAMA SENCILLO EN C: HOLA MUNDO...............................................................................4ELEMENTOS DE UN PROGRAMA EN C...................................................................5

CARACTERES PERMITIDOS EN C...................................................................................................5JUEGO DE CARACTERES EN C......................................................................................................6

COMENTARIOS...................................................................................................7COMENTARIOS DE UNA LÍNEA......................................................................................................7COMENTARIOS DE MÚLTIPLES LÍNEAS............................................................................................7

PALABRAS RESERVADAS....................................................................................8PALABRAS RESERVADAS EN C/C++.............................................................................................8

IDENTIFICADORES..............................................................................................9VARIABLES EN C...............................................................................................10CONSTANTES...................................................................................................10OPERADORES EN C...........................................................................................12

OPERADORES ARITMÉTICOS......................................................................................................12OPERADORES RELACIONALES....................................................................................................12OPERADORES LÓGICOS............................................................................................................13OPERADORES DE ASIGNACIÓN...................................................................................................13

ESTRUCTURA DE UN PROGRAMA EN C...............................................................14DIRECTIVA #INCLUDE..............................................................................................................14FUNCIÓN MAIN()....................................................................................................................15

ARREGLOS EN C...............................................................................................16DECLARACIÓN DE UN ARREGLO EN C..........................................................................................16ARREGLOS UNIDIMENSIONALES..................................................................................................17

Declaración de un arreglo unidimensional.....................................................................17DECLARACIÓN E INICIALIZACIÓN DE UN ARREGLO..........................................................................17ARREGLOS BIDIMENSIONALES....................................................................................................18MODIFICACIÓN DE UN ELEMENTO DE UNA MATRIZ..........................................................................19

Resultado en consola.....................................................................................................19

ESTRUCTURAS EN C/C++..................................................................................20CONCEPTO............................................................................................................................20

Un pequeño ejemplo......................................................................................................20

ESTRUCTURAS ANIDADAS.................................................................................22MANEJO DE ARCHIVOS EN C..............................................................................23

3

UNA PEQUEÑA REFERENCIA.......................................................................................................23ALGUNAS FUNCIONES PARA ARCHIVOS EN C.................................................................................23

fopen..............................................................................................................................23Fclose.............................................................................................................................25

Un ejemplo pequeño para abrir y cerrar el archivo llamado fichero.in en modo lectura:...........25feof................................................................................................................................26

Sintaxis de feof...........................................................................................................................26rewind............................................................................................................................26

Sintaxis de rewind.......................................................................................................................26LECTURA DE ARCHIVOS....................................................................................27

FUNCIONES PARA LEER ARCHIVOS..............................................................................................27fgetc...............................................................................................................................27fgets...............................................................................................................................27fread..............................................................................................................................29fscanf.............................................................................................................................29

ESCRITURA............................................................................................................................30fputc..............................................................................................................................30Fputs..............................................................................................................................30fwrite..............................................................................................................................30Fprintf............................................................................................................................31...................................................................................................................................... 31

FUNCIONES DE E/S EN C...................................................................................32ENTRADA DE DATOS: FUNCIÓN SCANF ().....................................................................................32

Sintaxis..........................................................................................................................32scanf (“cadena de control”, argumento1, argumento2…);.........................................................32

Tipos de datos y formatos en lenguaje C.......................................................................33SALIDA DE DATOS: FUNCIÓN PRINTF().........................................................................................34

Sintaxis..........................................................................................................................34printf (“cadena de control”, argumento1,argumento2…);..........................................................34Ejemplo en código.......................................................................................................................34Secuencias de escape.................................................................................................................35

FUNCIONE EN LENGUAJE C................................................................................36DEFINICIÓN:..........................................................................................................................36CRITERIOS PARA CREARLAS:.....................................................................................................36

Ejemplo de función........................................................................................................36SENTENCIA RETURN................................................................................................................36FUNCIÓN MAIN();....................................................................................................................37SCOPE DE VARIABLES..............................................................................................................37

Ejercicios realizados con funciones:...............................................................................38

ESTRUCTURAS DE CONTROL CONDICIONAL........................................................41TOMA DE DECISIONES..............................................................................................................41

La expresión condicional................................................................................................41Anidamiento o escalonamiento si-si no-si (if-else-if)......................................................41Ejemplo de if/else...........................................................................................................42

ESTRUCTURA DE CONTROL REPETITIVA O DE ITERACIÓN CONDICIONAL...............43CONTADORES Y ACUMULADORES...............................................................................................43

Contador........................................................................................................................43

4

Un for en acción.............................................................................................................44ESTRUCTURA DE CONTROL REPETITIVA MIENTRAS (WHILE)...............................................................44DO-WHILE............................................................................................................................44ESTRUCTURA DE CONTROL REPETITIVA DESDE (FOR)......................................................................45

5

Introducción a CC es un lenguaje de programación originalmente desarrollado por Dennis M. Ritchie entre 1969 y 1972 en los Laboratorios Bell, como evolución del anterior lenguaje B, a su vez basado en BCPL.

Al igual que B, es un lenguaje orientado a la implementación de Sistemas Operativos, concretamente Unix. C es apreciado por la eficiencia del código que produce y es el lenguaje de programación más popular para crear software de sistemas, aunque también se utiliza para crear aplicaciones.

Un programa sencillo en C: Hola Mundo

En este caso lo que hacemos es, de una manera sencilla, escribir nuestro primer “Hola Mundo” utilizando la sentencia cout de C++. Lo haremos así por la facilidad al usar cout. Más adelante utilizaremos printf que es propio de C.

6

La sentencia cout nos sirve para imprimir en la consola. La función de la sentencia endl es especificar el final de una línea.

Elementos de un programa en C

Caracteres permitidos en C.

Como en todo lenguaje de programación, existen juegos de caracteres. En el lenguaje C hay un sinnúmero de caracteres. Es muy importante conocer cuáles son, saber cuáles son permitidos por el lenguaje para así saber cuáles podemos usar en nuestros programas.

7

Juego de caracteres en C

8

Comentarios

En lenguaje C existen dos formas para escribir comentarios. Existen comentarios de una línea y cometarios de múltiples líneas.

Comentarios de una líneaLos comentarios de una línea se escriben utilizando la doble barra ( // ). Veamos un ejemplo.

Comentarios de múltiples líneasMuchas veces es necesario comentar muchas líneas de código, pero comentar línea a línea sería muy molesto y tedioso. Es por lo anterior que existe la manera de comentar bloques enteros de código de una manera muy fácil. Para comentar múltiples líneas se usa barra y asterisco para iniciar (/*), para finalizar asterisco y barra (*/).

9

Palabras Reservadas

En los lenguajes informáticos, una palabra reservada es una palabra que tiene un significado gramatical especial para ese lenguaje y no puede ser utilizada como un identificador de objetos en códigos del mismo, como ser variables.

Palabras reservadas en C/C++

No podemos usar palabras reservadas para nombrar a nuestros identificadores, esto sería un completo error.

Como podemos observar en la imagen, se está usando la palabra reservada class como nombre de identificador. Podemos apreciar a la izquierda de esta declaración

10

de variable que el IDE (en este caso CodeBlocks) nos muestra un cuadro pequeño de color rojo, este cuadro rojo es sinónimo de error.

Identificadores

Los identificadores deben ser correcto. No se pueden usar palabras reservadas, empezar con números, usar guiones o usar caracteres irreconocibles.

Como podemos ver en la imagen, el identificador es incorrecto, posee un guión en medio.

11

Variables en C

Una variable es una posición de memoria con nombre (identificador) donde se almacena un valor de un cierto tipo de dato. Toda variable que se usa en un programa debe ser declarada previamente.

Una declaración de variable reserva un espacio de almacenamiento en memoria. El proceso para crear una variable es escribir el tipo de dato, el identificador o nombre de variable y, en ocasiones, un valor inicial. Por ejemplo:

Constantes

Una constante guarda un valor al igual que una variable, la diferencia está en que este valor nunca podrá ser modificado durante toda la ejecución de un programa. En C/C++ existen cuatro tipo de constantes: constantes de tipo entero, caracter, flotante y cadena.

Sintaxis: <const> <tipo> <nombre> <=> <valor>;

12

Operadores en C

Operadores Aritméticos

Los operadores aritméticos toman los valores numéricos (literales o variables) como sus operando y devuelve un solo valor numérico.

Operadores Relacionales

Los operadores relacionales son símbolos que se usan para comparar dos valores. Si el resultado de la comparación es correcto la expresión considerada es verdadera, en caso contrario es falsa. Por ejemplo, 8>4 (ocho mayor que cuatro) es verdadera, se representa por el valor true del tipo básico boolean, en cambio, 8<4 (ocho menor que cuatro) es falsa, false.

13

Operadores Lógicos

Los operadores lógicos producen un resultado booleano y sus operandos son también valores lógicos o asimilables a ellos (los valores numéricos son asimilados a cierto o falso según su valor sea cero o distinto de cero).

El operador AND evalúa verdadero si se cumplen todas las condiciones. En cambio el operador OR evalúa verdadero si se cumple al menos uno. El NOT por su parte es un operador booleano que devuelve un valor TRUE (verdadero) si su operando es FALSE, y FALSE si su operando es TRUE.

Operadores de Asignación

14

Estructura de un programa en C

Un programa en C se compone de una estructura que ya fue definida por sus creadores. Esta estructura cuenta con componentes indispensables para el correcto funcionamiento de los programas. Si omitimos parte de estos componentes es muy probable que nuestros programas no funcionen como nosotros queremos.

Directiva #include

Como observamos en la figura anterior, en la parte superior encontramos #include. La directiva de preprocesador #include se usa en los lenguajes C y C++ para “incluir” las declaraciones de otro fichero en la compilación.

#include <stdio.h>

Es una directiva del preprocesador de C. Las líneas que comienzan con # son procesadas por el preprocesador antes de que el programa se compile. Esta línea en particular indica al preprocesador que incluya en el programa el contenido del

15

encabezado estándar de entrada/salida (stdio.h). Este encabezado contiene información que el compilador utiliza cuando compila las llamadas a las funciones de la biblioteca estándar de entrada/salida, como printf.

Función main()

La función main forma parte de todos los programas en C. Los paréntesis que aparecen después de main indican que main es un bloque de construcción de programas llamado función. Los programas en C contienen una o más funciones, una de las cuales debe ser main. Todo programa en C comienza su ejecución en la función main.

Cada programa de C tiene una función principal que se debe llamar main. Si su código sigue el modelo de programación Unicode, puede utilizar la versión de carácter ancho de main, wmain. La función main sirve como punto de partida para la ejecución del programa. Normalmente, controla la ejecución del programa dirigiendo las llamadas a otras funciones del programa. Un programa deja de ejecutarse normalmente al final de main, aunque puede finalizar en otros puntos del programa por distintos motivos. A veces, quizás cuando se detecta un error, puede resultar conveniente forzar la finalización de un programa.

16

Arreglos en CUn arreglo es un tipo de dato estructurado que almacena en una sola variable un conjunto limitado de datos o elementos del mismo tipo. Asimismo, es un conjunto de localidades de memoria contiguas donde la dirección más baja corresponde al primer elemento y la dirección más alta al último. Por sí mismo, el nombre del arreglo apunta a la dirección del primer elemento del arreglo. Los datos se llaman elementos del arreglo y su posición se numera consecutivamente: 1, 2, 3…n. Un arreglo en lenguaje C inicia en la posición cero, por lo tanto el i-ésimo elemento está en la posición i-1, es decir si el arreglo llamado a tiene n elementos, sus nombres son a[0], a[1], ..., a[n-1]. El tipo de elementos almacenados en el arreglo puede ser cualquier tipo de dato.Un arreglo se caracteriza por:

1. Ser una lista de un número finito de n elementos del mismo tipo.2. Almacenar los elementos del arreglo en memoria contigua.3. Tener un único nombre de variable que representa a todos los elementos y éstos se diferencian por un índice o subíndice.4. Acceder de manera directa o aleatoria a los elementos individuales del arreglo, por el nombre del arreglo y el índice o subíndice.

Declaración de un arreglo en C

17

Primeramente se indica el tipo de dato, luego el nombre de la variable y luego entre corchetes el tamaño del arreglo.

18

Arreglos Unidimensionales

Un arreglo unidimensional es un conjunto de n elementos del mismo tipo almacenados en memoria continua en un vector o lista. Para acceder a cada elemento del arreglo se requiere de un solo índice o subíndice, el cual representa la posición en la que se encuentra.

Declaración de un arreglo unidimensional

Este arreglo contiene diez elementos almacenados entre la posición (0-9). Para referirnos a un elemento en particular dentro del arreglo, especificamos el nombre del arreglo y el número de posición donde se encuentra ubicado. La posición del arreglo va entre paréntesis cuadrados o corchetes (“[ ]”).

19

Declaración e inicialización de un arreglo.

20

Arreglos Bidimensionales

Un arreglo bidimensional es un conjunto de n elementos del mismo tipo almacenados en memoria contigua en una matriz o tabla. A diferencia de los arreglos unidimensionales que sólo requieren de un subíndice, los arreglos bidimensionales para acceder a cada elemento del arreglo requieren de dos índices o subíndices declarados en dos pares de corchetes, donde el primer

corchete se refiere al tamaño de filas y el segundo al tamaño de columnas.

21

Modificación de un elemento de una matrizLos elementos de una matriz se pueden modificar en cualquier momento, sólo es necesario especificar el nombre del arreglo bidimensional, la posición tanto de la fila como de la columna y el nuevo valor. En seguida se muestra la sintaxis a seguir:

Resultado en consola.

22

Estructuras en C/C++

ConceptoEn la creación de soluciones para algunos problemas surge la necesidad de agrupar datos de diferente tipo o de manejar datos que serían muy difícil de describir en los tipos de datos primitivos, esta es la situación en la que debemos aprovecharnos de las características que hacen al lenguaje C especial, o sea el uso de estructuras, uniones y punteros. Una estructura contiene varios datos. La forma de definir una estructura es haciendo uso de la palabra clave struct.

Un pequeño ejemplo

23

24

En la imagen anterior podemos observar que "datos" es una instancia de "miEstructura" y no es necesario ponerla aquí. Se podría omitir de la declaración de "miEstructura" y más tarde declararla usando:

Como vemos, la instancia a la estructura está hecha desde el Main. Volvemos a utilizar la palabra reservada Struct, seguido del nombre de la estructura y luego el nombre de la nueva variable de tipo struct miEstructura.

25

Estructuras Anidadas

Como podemos ver, primero se crea una estructura llamada infopersona. Después se crea otra estructura llamada empleado. Dentro de la estructura empleado se instancia a estructura infopersona. Al hacer esto posee sus propiedades y también las de infopersona; a esto conocemos como anidamiento de estructuras.

26

Manejo de Archivos en C

Una pequeña referenciaEl estándar de C contiene varias funciones para la edición de ficheros, éstas están definidas en la cabecera stdio.h y por lo general empiezan con la letra f, haciendo referencia a file. Adicionalmente se agrega un tipo FILE, el cual se usará como apuntador a la información del fichero. La secuencia que usaremos para realizar operaciones será la siguiente:

Crear un apuntador del tipo FILE * Abrir el archivo utilizando la función fopen y asignándole el resultado de la

llamada a nuestro apuntador. Hacer las diversas operaciones (lectura, escritura, etc). Cerrar el archivo utilizando la función fclose.

Algunas funciones para archivos en Cfopen

Esta función sirve para abrir y crear ficheros en disco.

La sintaxis para abrir un archivo la podemos ver en la imagen.

27

Los parámetros de entrada de fopen son:

filename: una cadena que contiene un nombre de fichero válido.

Opentype o tipo de forma en que se abre el archivo: especifica el tipo de fichero que se abrirá o se creará:

Una lista de parámetros opentype para la función fopen son: "r”: abrir un archivo para lectura, el fichero debe existir. "w”: abrir un archivo para escritura, se crea si no existe o se

sobreescribe si existe. "a”: abrir un archivo para escritura al final del contenido, si no

existe se crea. "r+”: abrir un archivo para lectura y escritura, el fichero debe

existir. "w+”: crear un archivo para lectura y escritura, se crea si no existe

o se sobreescribe si existe. "r+b o rb+”: Abre un archivo en modo binario para actualización

(lectura y escritura). "rb": Abre un archivo en modo binario para lectura.

28

Fclose

Esta función sirve para poder cerrar un fichero que se ha abierto.

Un ejemplo pequeño para abrir y cerrar el archivo llamado

fichero.in en modo lectura:

El ejemplo anterior crea un puntero de tipo FILE. Luego en el puntero almacena lo que retorna la función fopen. fopen por su parte, está abriendo el archivo “fichero.in”, y lo abre en modo lectura. Luego se comprueba si ese fichero contiene algo o si está vacío. Si el fichero es igual a NULL, significa que el fichero no existe, y se manda a imprimir un mensaje de error. Por último se cierra el archivo utilizando la función fclose.

29

feof

Esta función sirve para determinar si el cursor dentro del archivo encontró el final (end of file). Existe otra forma de verificar el final del archivo que es comparar el caracter que trae fgetc del archivo con el macro EOF declarado dentro de stdio.h, pero este método no ofrece la misma seguridad (en especial al tratar con los archivos "binarios"). La función feof siempre devolverá cero (Falso) si no es encontrado EOF en el archivo, de lo contrario regresará un valor distinto de cero (Verdadero).

Sintaxis de feof

rewind

Literalmente significa "rebobinar", sitúa el cursor de lectura/escritura al principio del archivo.

Sintaxis de rewind

30

Lectura de ArchivosUn archivo generalmente debe verse como un string (una cadena de caracteres) que está guardado en el disco duro. Para trabajar con los archivos existen diferentes formas y diferentes funciones.

Funciones para leer archivos

fgetcEsta función lee un carácter a la vez del archivo que está siendo señalado con el puntero *archivo. En caso de que la lectura sea exitosa devuelve el carácter leído y en caso de que no lo sea o de encontrar el final del archivo devuelve EOF.

fgets

Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un cambio de línea '\n' o un final de archivo EOF. En este último caso, el carácter de cambio de línea '\n' también es leído.

El primer parámetro buffer lo hemos llamado así porque es un puntero a un espacio de memoria del tipo char (podríamos usar un arreglo de char). El segundo parámetro es tamaño que es el límite en cantidad de caracteres a leer para la función fgets. Y por último el puntero del archivo por supuesto que es la forma en que fgets sabrá a que archivo debe leer.

31

Nota: Este ejemplo no es de mi autoría.

32

fread

Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de un arreglo de elementos "count", cada uno de los cuales tiene un tamaño definido por "size". Luego los guarda en el bloque de memoria especificado por "ptr". El indicador de posición de la cadena de caracteres avanza hasta leer la totalidad de bytes. Si esto es exitoso la cantidad de bytes leídos es (size*count).

fscanfLa función fscanf funciona igual que scanf en cuanto a parámetros, pero la entrada se toma de un fichero en lugar del teclado.

33

Escritura

Así como podemos leer datos desde un fichero, también se pueden crear y escribir ficheros con la información que deseamos almacenar, Para trabajar con los archivos existen diferentes formas y diferentes funciones.

fputc

Esta función escribe un carácter a la vez del archivo que está siendo señalado con el puntero *archivo. El valor de retorno es el carácter escrito, si la operación fue completada con éxito, en caso contrario será EOF.

Fputs

La función fputs escribe una cadena en un fichero. La ejecución de la misma no añade el carácter de retorno de línea ni el carácter nulo final. El valor de retorno es un número no negativo o EOF en caso de error. Los parámetros de entrada son la cadena a escribir y un puntero a la estructura FILE del fichero donde se realizará la escritura.

fwriteEsta función está pensada para trabajar con registros de longitud constante y forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros de la misma longitud almacenados a partir de una dirección de memoria determinada. El valor de retorno es el número de registros escritos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria de donde se obtendrán los datos a escribir, el tamaño de cada registro, el número de registros a escribir y un puntero a la estructura FILE del fichero al que se hará la escritura.

34

Fprintf

La función fprintf funciona igual que printf en cuanto a parámetros, pero la salida se dirige a un archivo en lugar de a la pantalla.

35

Funciones de E/S en CEl lenguaje C no tiene palabras reservadas para la E/S estándar del sistema (teclado y pantalla). Estas operaciones se realizan mediante funciones de biblioteca que encontramos en el archivo de cabecera stdio.h (standard input-output header). La e/s con formato se realiza por medio de las funciones scanf() y printf.

Las f de scanf() y de printf() significan “con formato”.

Entrada de datos: función scanf ()La función scanf() se usa para la entrada y nos permite leer (introducir) datos desde el teclado y asignarlos a variables de C, de acuerdo con el formato especificado.

Sintaxisscanf (“cadena de control”, argumento1, argumento2…);

La cadena de control se encarga de hacer saber qué datos se almacenarán , es decir, qué tipos de datos serán, en este caso, son %d para especificar que se trata de entero, luego %f para real y %c para carácter, los siguientes argumentos pertenecen a cada uno de los elementos de la cadena de control respectivamente.

36

Tipos de datos y formatos en lenguaje C

37

Salida de datos: función printf()

La función printf() es similar a la función scanf(), pero se usa para la salida; permite escribir textos y datos en la pantalla con determinado formato.

Sintaxis

printf (“cadena de control”, argumento1,argumento2…);

Ejemplo en código

Esta función es similar a scanf, su diferencia radica en que este es para salida. Usa, al igual que scanf(), cadenas de control, donde se especifican los tipos de datos a imprimir. En los argumentos se especifican las variables a imprimir o los valores a imprimir cada uno correspondiente a los elementos de la cadena de control.

38

La cadena de control debe escribirse entre comillas (“ ”) y puede tener al menos uno de los tres elementos siguientes:

Los caracteres que se imprimirán en pantalla (los cuales se visualizarán idénticos).

Secuencias de escape. Uno o varios códigos de formato (indica de qué tipo de dato se trata); dichos

códigos determinan cómo se verán en pantalla los argumentos.

Secuencias de escape

39

Funcione en lenguaje C

Definición:– Las funciones son los bloques de construcción básicos de C. Dentro

de ellas se da toda la actividad del programa.

Criterios para crearlas:– Se usa la estrategia de “Dividir y Vencerás”, en otras palabras, es

realizar la partición de la tarea en subtareas más fáciles de abordar.

Todo problema se puede resolver con funciones o sin ellas, pero su uso adecuado hace que el programa sea más eficiente, fácil de leer y probar.

Ejemplo de función

void : especifica el tipo de valor que devuelve la función. Si no se especifica tipo, el compilador asume que es entero (int), en este caso es void, por ende, la función no devuelve nada.

Parámetros : es la lista de nombres de variables separados por comas con sus tipos asociados que reciben los valores de los argumentos actuales de la llamada a la función.

Sentencia return

La sentencia return es muy usada en las funciones, es indispensable en las funciones distintas a void, ya que estas retornan algún valor luego de su ejecución: return es usado para eso, para retornar valores.La palabra reservada return es la que permite que una función pueda devolver un valor al lugar de donde fue llamada.

40

Las funciones terminan su ejecución ya sea a través de la ejecución de la última instrucción o utilizando la sentencia return.

Una función puede retornar valor sólo cuando el tipo de retorno no es void, como se ha explicado antes.

Las funciones que son de tipos distintos de void pueden ser utilizadas como operando en otras expresiones del lenguaje.

función main();La función main() es la función principal y cuenta con las características que cuentan otras funciones. La funcion main() puede recibir parámetros, puede retornar valores y puede llamar a otras funciones desde su interior.

Cada programa de C tiene una función principal que se debe llamar main. La función main sirve como punto de partida para la ejecución del programa. Normalmente, controla la ejecución del programa dirigiendo las llamadas a otras funciones del programa. Un programa deja de ejecutarse normalmente al final de main, aunque puede finalizar en otros puntos del programa por distintos motivos. A veces, quizás cuando se detecta un error, puede resultar conveniente forzar la finalización de un programa.

Scope de variables Variables Locales:

Se declaran dentro de la función y sólo están disponibles durante su ejecución.

Se crean cuando se entra en ejecución una función y se destruyen cuando se termina.

Variables globales: Se declaran fuera de las funciones. Pueden ser utilizadas por todas las

funciones. Existen durante toda la vida del programa.

Las variables declaradas dentro de una función solo podrán ser usadas desde este ámbito, pero si las variables son globales, es decir, están fuera de cualquier función, estas podrán ser utilizadas por cualquier función del programa.

41

Ejercicios realizados con funciones:

42

43

Estructuras de control condicionalEs una estructura con una sola entrada y una sola salida en la cual se realiza una acción (una o varias instrucciones) de entre varias, según una condición; o se realiza una acción según el cumplimiento o no de una determinada condición. La condición puede ser simple o compuesta.

Los programas, para un mejor funcionamiento y para poder realizar un número mayor de tareas, deben permitir emplear acciones alternativas a fin de poder elegir una de ellas cuando la situación lo requiera. Por lo tanto, la ejecución de una línea o grupos de líneas del programa depende de si cumplen o no una condición.

Toma de decisionesLa instrucción si (if/else) nos permite tomar decisiones, podemos hacer una pregunta y la contestación sólo puede ser verdadera o falsa, es decir, sí o no.

La expresión condicional

La condición es una expresión booleana. Si el resultado de la expresión:• Es cero, se considera una condición falsa.• No es cero, se considera una condición cierta.

Dentro del if debe haber una condición, que podrá evaluarse verdadera o falsa. Si es verdadera se ejecutará lo que esté dentro del if, en caso contrario no lo hará y ejecutará el else.

Anidamiento o escalonamiento si-si no-si (if-else-if)

El concepto de anidamiento es muy utilizado en la programación y consiste en insertar (anidar) una estructura dentro de otra.La expresión “si anidados” se refiere a que podemos utilizar una sentencia si (if ) dentro de otra sentencia si (if ). Esto se emplea cuando se tienen que cumplir varias condiciones para poder ejecutar una acción.Uno de los aspectos más confusos de las sentencias si (if ) en el lenguaje de programación es el si (if ) anidado. Un si (if ) anidado es una sentencia si (if ) que es el objeto de otro si (if ) o si no (else). La razón por la que los si (if ) anidados son tan problemáticos es que resulta confuso saber qué else se asocia con qué si (if).

44

Ejemplo de if/else

En este caso la condición siempre es entorno a salario anual, si resulta falsa la primera condición del primer if, se sigue con las demás condiciones hasta que una se cumpla.

45

Estructura de control repetitiva o de iteración condicional

La repetición de una acción (una o varias instrucciones) se lleva acabo mientras se cumpla cierta condición; para que la acción termine, la acción misma debe modificar la(s) variable(s) de control que interviene(n) en la condición. Dicha condición puede estar predefinida como en el ciclo desde (for); o no predeterminada, como en los bucles mientras (while) y hacer-mientras (do_while).

Bucles, ciclo o iteración. Es un segmento de un algoritmo o programa, cuya(s) instrucción(es) se repite(n) un número conocido o indefinido de veces mientras se cumpla una determinada condición. En cada vuelta del ciclo comprueba si la condición es verdadera, rompiéndose el ciclo cuando es falsa. La condición en algún momento tiene que ser falsa ya que en caso contrario el bucle se hará infinito.

Contadores y acumuladores

Estas dos palabras se usan mucho en programación para referirse a variables que van incrementando o decrementando su valor a lo largo de la ejecución del algoritmo o programa. Normalmente serán de tipo numérico.

ContadorUn contador es una forma de controlar a un bucle. Es una variable cuyo valor se incrementa o decrementa en una cantidad constante cada vez que se produce un

46

determinado suceso o acción en cada repetición; dicha variable controla o determina la cantidad de veces que se repite un proceso o dato. Sintaxis:

Un for en acción

Este for se repite de 0 a 99, es decir 100 veces. Por cada iteración se imprime el valor de i, el cual va a aumentando en uno por cada vuelta.

Estructura de control repetitiva mientras (while)

Al ejecutarse la instrucción mientras (while), se evaluará la expresión booleana suministrada en los paréntesis (condición), y si su valor es verdadero (distinto de cero) se realizará el ciclo o bucle (una o varias instrucciones).Después, la condición es reevaluada y se procede de la misma manera. Cuando la condición se vuelve falsa (es decir, cero), en la siguiente evaluación se dará por terminado el ciclo mientras (while).

47

Do-While

Funciona de la mismo forma que un while con la única diferencia de que do-while ejecuta las instrucciones al menos una vez ya que evalúa la condición al final.

Estructura de control repetitiva desde (for)

El desde (for) es la estructura repetitiva más utilizada y simple de manejar, ya que repite un conjunto de instrucciones un número determinado de veces. Una de sus aplicaciones principales son los arreglos.

En la instrucción for, primero se ejecutará la(s) inicialización(es), posteriormente se evaluará la condición y, en caso de ser verdadera (no ser cero), se ejecutará(n) la(s) instrucción(es) que compone(n) el ciclo.

48

Imprime los valores de i en cada vuelta.