Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Primer Semestre
Programa de la asignatura:
Fundamentos de programación
Índice
Unidad 2: introducción al lenguaje c ................................................................................................ 3
Presentación de la unidad ....................................................................................................................... 3
Propósitos............................................................................................................................................................. 3
Competencia específica ............................................................................................................................ 4
2.1. Componentes de un programa en lenguaje c.................................................................. 4
2.1.1. Instrucciones ...........................................................................................................................................8
2.1.2. Palabras reservadas ...........................................................................................................................8
2.1.3. Estructura general de un programa ...................................................................................... 9
2.2. Tipos de datos .......................................................................................................................................... 11
2.3. Variables y constantes ...................................................................................................................... 13
2.3.1. Identificadores ..................................................................................................................................... 14
2.3.2. Declaración e inicialización de variables.......................................................................... 15
2.3.3. Tipos de constantes ........................................................................................................................ 17
2.3.4. Declaración de constantes ........................................................................................................ 19
2.4. Expresiones matemáticas ............................................................................................................ 20
2.4.1. Tipos de operadores ........................................................................................................................ 21
2.4.2. Evaluación de expresiones ....................................................................................................... 24
2.5. Bibliotecas y funciones.................................................................................................................... 26
2.5.1. Funciones matemáticas .............................................................................................................. 28
2.5.2. Funciones de entrada y salida................................................................................................ 28
2.6. Codificación de algoritmos ........................................................................................................... 31
2.7. Estructuras de control ..................................................................................................................... 39
2.7.1. Estructuras selectivas ................................................................................................................... 40
2.7.2. Estructuras repetitivas ................................................................................................................. 58
2.7.3. Estructuras anidadas .................................................................................................................... 78
Cierre de la unidad ....................................................................................................................................... 81
Fuentes de consulta .................................................................................................................................. 82
Unidad 2. Introducción al lenguaje C
Presentación de la Unidad
Propósitos
Competencia específica
/* Definición de función
Principal */
main( )
{
printf(“Hola mundo… \n”);
}
std: estándar
Los compiladores de lenguaje C ofrecen distintas directivas, sin embargo, las que
utilizaremos son:
#define, que sirve para definición de constantes y/o macros.
#include, que se utiliza para incluir otros archivos.
Unidad 2. Introducción al lenguaje C
2.1.1. Instrucciones
Las instrucciones simples se distinguen porque terminan con punto y coma “;”.
La sintaxis es:
<instrucción>;
añadidas por el comité del ANSI: enum, const, signed, void y volatile), todas ellas
escritas con minúsculas.1
Una vez que se han descrito los diferentes elementos que integran un
programa de lenguaje C, en la siguiente sección se describe la estructura
general de un programa en C.
1 En este punto es importante destacar que el lenguaje C distingue entre mayúsculas y minúsculas.
Unidad 2. Introducción al lenguaje C
/* Declaraciones globales */
const float PI = 3.1416;
/* Función Principal */
main( )
{
/* Declaraciones de variables locales de la
función main*/
float radio, area;
Por el momento, basta con que observes la estructura del programa, que se
hace evidente con los comentarios, el significado de cada una de las líneas de
código se irá definiendo en las siguientes secciones. Para cerrar esta sección
en la siguiente figura se muestra la ejecución del programa con la entrada
radio=3.
Unidad 2. Introducción al lenguaje C
En la Unidad 1 se mencionó que todos los datos que son procesados por una
computadora se almacenan en la memoria principal y, no importa de qué tipo
sean, se representan por medio de unos y ceros, sin embargo, no todos se
pueden representar con el mismo número de bits2, esto sí depende del tipo del
que se trate. Por ejemplo, los caracteres como: ‘a’, ‘@’,’Z’, entre otros, se
representan utilizando 8 bits, en cambio para representar un número decimal
se utilizan, al menos, 32 bits; por lo que cuando se crea un espacio de memoria
es necesario indicar qué tipo de dato se desea almacenar ahí, para que se
reserve la cantidad de celdas de memoria que se necesitan y las operaciones
que se pueden realizar con ellos.
Enteros
Numéricos
Decimales
Simples
Lógicos (verdadero o falso)
Alfanuméricos (caracteres)
Unidimensionales
Estructurados Arreglos
Multidimensionales
2 Recuerda que un bit se definió como la unidad mínima de información, esto es, 1 ó 0.
Unidad 2. Introducción al lenguaje C
Estructuras o registros
Tipos de datos (Cairó, 2006).
Por el momento, sólo nos enfocaremos en los tipos de datos simples definidos
en el estándar de C, en la siguiente tabla se muestran los tipos de datos simples
en C:
Una vez que conocemos los tipos de datos que se pueden representar en
lenguaje C, es conveniente saber cómo se reservan los espacios de memoria
en donde son almacenados, esto se explica en el siguiente tema.
2.3.1. Identificadores
Una vez habiendo definido las reglas para escribir los nombres de las variables
y los tipos básicos que pueden tener, estás listo para descubrir cómo se crean
las variables en lenguaje C. A esta acción se le denomina declaración de
variables.
<tipo><identificador>;
<tipo><identificador1>, … , <identificadorN>;
<tipo><identificador>=<valor>;
MEMORIA
Dirección Contenido Dirección Contenido
51
01 3.0
radio
02 52
18
edad
03 53
54
04 0.0
area
05 55
… 56
Memoria y declaración e inicialización de variables.
Por otro lado, las constantes simbólicas representan datos permanentes que
nunca cambian. Ahondaremos en este tema en la siguiente sección.
Este tipo de constantes mantienen dos ventajas muy claras sobre las
constantes literales, una es que la escritura del código es más clara y otra que
facilita la edición de los valores contenidos en el código del programa. En el
siguiente subtema ahondaremos en esto.
#define<identificador><valor_constante>
Por ejemplo:
#define PI 3.1416
const<tipo><identificador> = <valor_constante>;
Por ejemplo:
La directiva #define debe ser al principio del programa antes del main, en
cambio, la declaración de una constante mediante const puede ser dentro o
fuera de las funciones al igual que las declaraciones de variables.
Una expresión matemática puede ser un número, una variable, una constante
o la combinación de operadores y todas las anteriores. Toda expresión al ser
evaluada produce un valor.
una venta, etc. En cambio, las expresiones booleanas son la base para construir
programas que pueden tomar decisiones.
b) ¿x es un número par?
Sabemos que un número es par si es divisible entre 2, en otras palabras, si
el residuo de la división entre dos es cero, lo cual se puede expresar con el
operador de módulo, que devuelve el residuo de una división.
Los operadores aritméticos definidos en C son: “+” (suma), “-” (resta), “*”
(multiplicación), “/” (división) y “%”(módulo). Este último representa el residuo
de dividir dos números enteros, por ejemplo, si realizamos la división de 6 entre
15 (15/6), el cociente es 2 y el residuo es 3, al aplicar el operador módulo a estos
valores tenemos:
15 % 6 → 3
21 % 4 → 1
x++; → 6
x--; → 4
(x % 2 == 0)
3Si deseas más información se te recomienda consultar (Joyanes & Zohanero, 2005).
Unidad 2. Introducción al lenguaje C
Con esta información es posible codificar algoritmos que requieran este tipo
de operaciones. Por ejemplo, la fórmula para calcular el área de una
circunferencia, que aparece en el programa 3.2.
area = PI * pow(radio,2);
En los programas que hemos visto aparece la función de salida estándar printf,
que se encarga de imprimir un mensaje en la pantalla. La sintaxis general es:
4 En (Kernighan & Ritchie, 1991) puedes consultar las funciones que están definidas en cada una de las bibliotecas estándar.
Unidad 2. Introducción al lenguaje C
printf(<cadena_de_control>, <lista_de_identificadores>);
Especificador Acción
%d Insertar un entero (int)
%i Insertar un entero tipo (int)
%ld Insertar un entero tipo (long)
Insertar un número flotante
%f
tipo (float)
Insertar un número de tipo
%lf
(double)
%c Insertar un caracter (char)
La salida es:
El perímetro es 18.85
En lenguaje C la lectura de datos por medio del teclado se realiza con la función
scanf, en la cual se deben especificar de antemano los tipos de datos que se
desea recibir, además de los identificadores de las variables donde se desean
almacenar.
scanf(<cadena_de_control>,<lista_de_direcciones_de_variables>);
memoria de las variables donde se almacenarán los datos que el usuario del
programa introduzca a través del teclado.
Unidad 2. Introducción al lenguaje C
Nota: Es frecuente que las personas olviden escribir el & antes del identificador
de una variable, al utilizar la función scanf, cuestión que no es supervisada por
el compilador y genera un error en el momento que se ejecuta el programa.
5 En este apartado Análisis, las palabras entre paréntesis remarcadas con negritas, son los nombres propuestos para las variables que
involucra el problema.
Unidad 2. Introducción al lenguaje C
Por último, los billetes sólo pueden ser de $500, $200, $100, $50 y $20 y las
monedas sólo son de $10, $5, $2 y $1. Por el momento supondremos que el
usuario siempre ingresa datos correctos.
Constantes:
PRECIO = 45
Variables:
nboletos: entero, representa el número de boletos que quiere el
cliente.
total: entero, es la cantidad de dinero que el cliente debe pagar.
pago: entero, monto del pago del cliente.
cambio: entero, monto del cambio.
Inicio
Imprimir “Proporciona el número de boletos”
Leer nboletos
total = nBoletos * PRECIO
Imprimir “Proporciona tu pago”
Leer pago
cambio = pago – total
Imprimir “Tu cambio es”, cambio
Imprimir “El número de billetes de 200 pesos
es”, cambio/200
cambio = cambio módulo 200
Imprimir “El número de billetes de 100 pesos
es”, cambio/100
cambio = cambio módulo 100
Imprimir “El número de billetes de 50 pesos
es”, cambio/50
cambio = cambio módulo 50
Imprimir “El número de monedas de 10 pesos es”,
cambio/10
cambio = cambio módulo 10
Unidad 2. Introducción al lenguaje C
Dato
Estado de la memoria Dato de
Instrucción de Operaciones
(variables y constantes) salida
entrada
PRECIO nBoletos total pago cambio
Inicio - - -
45 - - - -
Imprimir
Proporciona
“Proporciona el PRECIO nBoletos total pago cambio
- - el número
número de 45 - - - -
de boletos
boletos”.
Leer nBoletos PRECIO nBoletos total pago cambio
5 - -
45 5 - - -
total =
total = 5*45 PRECIO nBoletos total pago cambio
nBoletos*PRECIO - -
=225 45 5 225 - -
Imprimir
PRECIO nBoletos total pago cambio Proporciona
“Proporciona tu - -
45 5 225 - - tu pago
pago”
Leer nBoletos PRECIO nBoletos total pago cambio
500 - -
45 5 225 500 -
cambio =
cambio = pago - PRECIO nBoletos total pago cambio
- 500-225 = -
total 45 5 225 500 275
275
Imprimir “Tu
PRECIO nBoletos total pago Cambio Tu cambio
cambio es”, - -
45 5 225 500 275 es 275
cambio.
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 275/200 = 1 de billetes
billetes de $200 45 5 225 500 275
de $200 es 1
es”, cambio/200
Unidad 2. Introducción al lenguaje C
cambio =
cambio = cambio 275 mod PRECIO nBoletos total pago Cambio
- -
módulo 200 200 45 5 225 500 75
=75
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 75/100 = 0 de billetes
billetes de $100 45 5 225 500 75
de $100 es 0
es”, cambio/100
cambio =
cambio = cambio PRECIO nBoletos total pago Cambio
- 275 mod 100 -
módulo 100 45 5 225 500 75
=75
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 75/50= 1 de billetes
billetes de $50 45 5 225 500 75
de $50 es 1
es”, cambio/50
cambio = 75
cambio = cambio PRECIO nBoletos total pago Cambio
- mod 50 -
módulo 50 45 5 225 500 25
=25
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 25/50= 0 de billetes
billetes de $20 45 5 225 500 25
de $50 es 0
es”, cambio/20
cambio =
cambio = cambio PRECIO nBoletos total pago Cambio
- 25 mod 20 -
módulo 20 45 5 225 500 5
=5
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 5/10= 0 de monedas
monedas de $10 45 5 225 500 25
de $10 es 0
es”, cambio/10
Unidad 2. Introducción al lenguaje C
cambio = 5
cambio = cambio PRECIO nBoletos total pago Cambio
- mod 10 -
módulo 10 45 5 225 500 5
=5
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 5/5= 1 de monedas
monedas de $5 45 5 225 500 5
de $5 es 1
es”, cambio/5
cambio = 5
cambio = cambio PRECIO nBoletos total pago Cambio
- mod 5 -
módulo 5 45 5 225 500 0
=0
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- 0/2= 0 de monedas
monedas de $2 45 5 225 500 0
de $2 es 0
es”, cambio/2
cambio = 0
cambio = cambio PRECIO nBoletos total pago Cambio
- mod 2 -
módulo 2 45 5 225 500 0
=0
Imprimir “El
El número
número de PRECIO nBoletos total pago Cambio
- - de monedas
monedas de $1 45 5 225 500 0
de $1 es 0
es”, cambio
PRECIO nBoletos total pago Cambio
Fin - - -
45 5 225 500 0
Prueba de escritorio.
Implementación: Por último, sólo queda codificar el algoritmo en lenguaje C, como se muestra a
continuación:
/* Descripción: Simulador de la caja de cobro de un cine.*/
/* Directivas al procesador */
#include<stdio.h>/* Funciones de entrada y salida */
#include<stdlib.h>/* Funciones del sistema */
/* Función Principal */
main( )
{
/*Declaración de variables y constantes */
constint precio = 45;
intnBoletos, total, pago, cambio;
/*Mensaje de bienvenida*/
printf("********** Venta de boletos CineESAD************\n\n");
/*Datos de entrada*/
printf("Proporcione el numero de boletos que desea comprar:\t");
scanf("%d",&nBoletos);
La segunda parte está dedicada a las estructuras repetitivas, para las cuales
se sigue la misma estrategia, verás cómo se pueden solucionar problemas
utilizando este tipo de estructuras y también analizarás su semántica y
sintaxis en lenguaje C. De esta manera, al finalizar podrás construir
programas que incluyan cualquier tipo de estructura de control.
if(<condición>)
Si <condición>
entonces
<instrucciones>
<instrucciones>
Fin Si
Si angulo=90 entonces
Imprimir "El ángulo es recto"
Fin_Si
/* Función Principal*/
main ()
{ /*Inicio de la función Principal*/
/*Declaración de variables */
intangulo;
/*Mensaje de bienvenida*/
printf ("\nEste programa determina de que tipo es el ángulo
dado.");
/*Instrucciones */
printf ("\n\nIngrese la medida del ángulo (grados): ");
scanf ("%d",&angulo);
if (angulo<=0 || angulo>=360)
printf ("\n No tiene clasificación");
if (angulo>0 &&angulo<90)
printf ("\n El ángulo es agudo");
if (angulo==90)
printf ("\n El ángulo es recto");
if (angulo>90 &&angulo<180)
printf ("\n El ángulo es obtuso");
if (angulo ==180)
printf ("\n El ángulo es llano");
if (angulo>180 &&angulo<360)
printf ("\n El ángulo es concavo");
printf ("\n\n\t");
system ("pause");
} /*Fin de la función Principal*/
Ejemplo de aplicación de estructura selectiva simple: Codificación tipoAngulo.c
A continuación, se muestra la pantalla correspondiente a la ejecución del
programa anterior introduciendo el mismo ángulo que se utilizó en la prueba
de escritorio.
𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0.
Para resolver este problema se utilizará la fórmula general:
−𝑏 ± √𝑏 2 − 4𝑎𝑐
𝑥=
2𝑎
Por lo que los datos que requerimos son los coeficientes de la ecuación (a, b
y c) y el resultado deseado serán las raíces. También se debe considerar que
un polinomio tiene raíces reales si se cumple con la siguiente condición:
𝑏 2 ≥ 4𝑎𝑐
/* Programa: ecuacion.c
Descripción: Solución de ecuaciones de segundo grado utilizando
*/
/* Bibliotecas */
#include<stdio.h>/* Biblioteca de entrada y salida estándar */
#include<stdlib.h>/* Biblioteca para las funciones del sistema */
#include<math.h>/* Biblioteca para utilizar funciones matemáticas:
pow para calcular la potencia
sqrt para calcular la raíz cuadrada*/
/* Función Principal*/
main ( )
{
/*Declaración de variables */
double a, b, c, x1, x2, det;
/* Mensaje de bienvenida */
printf("El siguiente programa calcula las raíces de un polinomio de
segundo grado\n");
printf("\n\t\t ax^2 + bx + c = 0");
/* Datos de entrada */
printf ("\nIntroduzca los coeficientes de a,b y c:");
scanf ("%lf,%lf,%lf",&a,&b,&c);
det = pow (b,2)-4*a*c;
Las estructuras selectivas múltiples permiten escoger uno de varios caminos posibles.
“permite que el flujo del diagrama se bifurque por varias ramas en el punto
de la toma de decisión. La elección del camino a seguir depende del
contenido de la variable conocida como selector, la cual puede tomar valores
de un conjunto previamente establecido.” (Cairó, 2006, p. 58).
Pseudocódigo Lenguaje
Casos para<expresión>
caso<valor1>: switch (<expresión>)
<instruccionesCaso1> {
caso<valor2>: case<valor1>:
<instruccionesCaso2> <instrucciones1>;
… break;
otros casos: case<valor2>:
<instruccionesOtros> <instrucciones2>;
Fin_Casos break;
default:
<instruccionesOtras>
}
Diagrama de Flujo
#include<stdio.h>
#include<stdlib.h>
/*Función principal*/
main()
{
/*Declaración de variables*/
int nota;
/*Mensaje de bienvenida */
printf("\nEl siguiente programa lee una calificación con número,
\ndetermina que tipo de calificación es\n");
/*Datos de entrada*/
printf("\nInserte una calificación numérica: ");
scanf("%d",¬a);
/*Comparación*/
switch(nota)
{
case 0: case 1: case 2: case 3: case 4: case 5:
case 6: printf("\n\n\t\"Reprobado\"");
break;
case 7: printf("\n\n\t\"Suficiente, Aprobado\"");
break;
case 8: printf("\n\n\t\"Bien, Aprobado\"");
break;
case 9: printf("\n\n\t\"Notable, Aprobado\"");
break;
case 10: printf("\n\n\t\"Sobresaliente, Aprobado\"");
break;
default: printf("\n\n\t\"Esa nota es incorrecta\"");
}
printf ("\n\n\t\t");
system ("pause");
}
Problema de estructura selectiva múltiple: Codificación de un programa que determina un valor
cualitativo a partir del valor numérico 8.
En la siguiente figura se muestra la ejecución de este programa con el valor
de entrada igual a 8.
A lo largo de este tema has estudiado los tres tipos de estructuras selectivas
y por medio de los ejemplos presentados te has dado cuenta de la
importancia y utilidad de estas estructuras, sin ellas sería imposible construir
programas que implicaran la toma de decisiones. Sin embargo, todavía
existen problemas que requieren de otro tipo de estructuras que permitan
repetir una tarea un número determinado de veces, la siguiente sección está
dedicada a este tema.
Con lo anterior puedes darte cuenta que para las estructuras de control
repetitivas es muy importante el uso de variables auxiliares y que por la
frecuencia con la que se utilizan dentro de un algoritmo y por la función que
realizan dentro del mismo toman un nombre especial: contadores,
acumuladores e interruptores.
Un interruptor es una variable que puede tomar dos posibles valores a lo largo
de la ejecución del programa, éstos son: 1 (encendido/abierto) y 0
(apagado/cerrado), de ahí su nombre. También se le conoce como bandera y
se utilizan principalmente para registrar la ocurrencia o no de un suceso.
Mientras while
<condición>hacer (<condición>)
Condición V F
<instrucciones> <instrucciones>;
Fin mientras
instrucciones
Así que en este caso se usará un ciclo que vaya leyendo una a una las
temperaturas (almacenándolas en la variable 𝑡𝑒𝑚𝑝𝐹) y acumulando la suma
en la variable 𝑠𝑢𝑚𝑎𝐹, estas acciones se repetirán hasta que el usuario
introduzca un número menor a -460. De esta manera, la condición de
término es: 𝑠𝑢𝑚𝑎𝐹 ≥ −460; por lo que antes de iniciar el ciclo se debe pedir la
primera temperatura, para que se compare con la condición y si es mayor a -
460 se acumule en la suma. Además, se utilizará un contador para registrar el
número de temperaturas que se lean. Finalmente, cuando se termina el ciclo
se divide el resultado de la suma de las temperaturas entre el valor del
contador. Lo anterior se expresa en el siguiente pseudocódigo.
Inicio
c←0, sumaF←0
Imprimir "Ingrese la primera temperatura registrada en grados
Fahrenheit:"
Leer tempF
Mientras (tempF≥-460)
c←c+1
sumaF=sumaF+tempF
Imprimir "Ingrese la siguiente temperatura en grados
Fahrenheit (un número mayor a -460)
para calcular el promedio "
Leer tempF
Fin Mientras
promF←sumaF/c
Imprimir “El promedio de las temperaturas es” promF
Fin
Ejemplo de estructura repetitiva Mientras (while): pseudocódigo para calcular el Promedio de
temperaturas.
Ejemplo de estructura repetitiva Mientras (while): diagrama de flujo para calcular el Promedio de
temperaturas.
En la siguiente tabla se muestra una prueba de escritorio para las
temperaturas 75, 78, 79 y para concluir el ciclo -2000.
Ejemplo de estructura repetitiva Mientras (while): prueba de escritorio para calcular el Promedio de
temperaturas.
En la tabla 4.9 se puede observar como el mismo conjunto de instrucciones
se repite tres veces (3 iteraciones), en cada una se valida la condición y el ciclo
termina sólo cuando ésta no se satisface por el estado de las variables
implicadas en la expresión booleana. Una vez que se ha ilustrado el
funcionamiento del ciclo Mientras y que se ha verificado que sí funciona, el
siguiente paso es la codificación, para la cual se determinó utilizar una
variable para representar el valor centinela que controla el ciclo.
/* Programa: promTemp.c
Descripción: Calcula el promedio de las temperaturas que el
usuario ingresa.
*/
#include<stdio.h>
#include<stdlib.h>
#define centinela -460
/* Función principal */
main () {
/*Declaración de acumuladores y contadores*/
float tempF,promF, sumaF=0;
int c=0;
Ejemplo de estructura repetitiva Mientras (while): ejecución del programa para calcular el Promedio
de temperaturas.
El ciclo para, en lenguaje C for, evaluará una condición y mientras ésta sea
verdadera se ejecutará el conjunto de instrucciones definidas en el cuerpo de
la estructura, generalmente las repeticiones se controlan por un contador, ya
que como parte de su sintaxis tiene la opción de inicializar una variable (el
contador) e incrementarlo o decrementarlo. Es conveniente utilizar este tipo
de estructura cuando se conoce de antemano el número de veces que se
debe repetir el ciclo (ciclos definidos). Sus representaciones se muestran en
la siguiente tabla.
Pseudocódigo Diagrama de Flujo
Desde
<inicialización>Mientras<condición>,
<incr/decr>
<Instrucciones>
Fin desde
Lenguaje C
for (<inicialización>;<condición>; <inc/dec>)
<instrucciones>
Representaciones de la estructura repetitiva para-mientras (for).
Inicio
Imprimir "Ingrese el total de empleados: "
Leer n
nom=0
Desde c=1, Mientras (c<=n), c=c+1
Imprimir “Ingresa el salario del trabajador”, c
Leer sal
nom=nom+sal
Fin desde
Imprimir “La nómina a pagar es en total $”, nom
Fin
Problema de aplicación de una estructura para-mientras (for): pseudocódigo Nómina.
Problema de aplicación de una estructura para-mientras (for): diagrama de flujo Nómina.
Por lo tanto, la salida del algoritmo es: “La nómina a pagar es $45”. La
codificación sería la siguiente.
/* Programa: nomina.c
Descripción: calcula la nómina a pagar de n trabajadores
*/
/*directivas de preprocesador*/
#include<stdio.h>
#include<stdlib.h>
/*Función Principal*/
main ()
{
/* Declaración de las variables */
int n,c;
float nom,sal;
/*Acumulador de salarios*/
nom=nom+sal;
}
printf(“\n La nómina a pagar es $&.2f”, nom);
}
Problema de aplicación de una estructura para-mientras (for): codificación del programa Nomina.c
Problema de aplicación de una estructura para-mientras (for): ejecución del programa Nomina.c.
Hacer do
<instrucciones> <instrucciones>;
while(<condición>);
Mientras
<condición>Fin
Por el funcionamiento de la estructura, el caso típico del uso del do-while son
los menús. Para ejemplificar lo anterior se propone el siguiente problema.
Inicio
Hacer
Imprimir "Realiza Cálculos trabajando la 2a. Ley
de Newton"
Imprimir " ------------------------------------------------"
Imprimir " a. Fuerza."
Imprimir " b. Aceleración."
Imprimir " c. Masa."
Imprimir " d. Salir."
Imprimir " Elegir una Opción: "
Leeropc
Selecciona (opc)
Caso 1: Imprimir "Ingresa La masa:”
Leer m
Imprimir “Ingresa la aceleración:”
Leer a
f = m*a
Imprimir “Fuerza = ”, f
Caso 2: Imprimir "Ingresa la fuerza:”
Leer f
Imprimir “Ingresa la masa:”
Leer m
a = f/m
Imprimir “Aceleración = ”, a
Caso 3:Imprimir "Ingresa la fuerza:”
Leer f
Imprimir “Ingresa la aceleración:”
Leer a
m = f/a
Imprimir “Masa = ”, m
Caso 4: Imprimir "Adios"
Otro: Imprimir " Opción inválida"
Fin_Selecciona
Mientras (opc!=4) Fin
Fin
Problema de estructura hacer-mientras (do-while): pseudocódigo Segunda ley de Newton.
/* Programa: newton.c
Descripción: Muestra un menú para calcular la aceleración,
fuerza o masa, conforme a la segunda ley de Newton */
/*directivas de preprocesador*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
/*Función Principal*/
main ()
{ /*Declaración de variables*/
char opc;
float f,m,a;
Observa que dentro del cuerpo del ciclo se definió una estructura selectiva,
es decir, que las instrucciones del cuerpo de cualquier estructura compuesta,
sea repetitiva o selectiva, pueden contener a otras. Uno de los casos más
utilizados es el anidamiento de los if´s, de lo cual hablaremos en el siguiente
tema.
El programa en C es el siguiente:
/* Programa: tipoAngulo.c
Descripción: Determina el tipo de angulo (agudo, recto,
obtuso, llano o cóncavo)
*/
#include<stdio.h>
#include<stdlib.h>
/* Función Principal*/
main ()
{
/*Declaración de variables */
intangulo;
/*Mensaje de bienvenida*/
printf ("\nEste programa determina de qué tipo es el ángulo
dado.");
/*Instrucciones */
printf ("\n\nIngrese la medida del ángulo (grados): ");
scanf ("%d",&angulo);
if (angulo<=0 || angulo>=360)
printf ("\n No tiene clasificación");
else if (angulo<90)
printf ("\n El ángulo es agudo");
else if (angulo==90)
printf ("\n El ángulo es recto");
else if (angulo<180)
printf ("\nEl ángulo es obtuso");
else
printf ("\nEl ángulo es cóncavo");
printf ("\n\n\t");
system ("pause");
}
Problema de sentencias de estructuras anidadas: codificación tipoAngulo.c
Con este ejemplo se da por terminada esta sección, ahora ya conoces todas
las estructuras y has visto cómo funcionan y qué tipo de situaciones se puede
modelar con ellas. Aunque cabe destacar que para solucionar cualquier
problema basta con que sepas utilizar el ciclo while y la estructura selectiva
if-else, pues ya se mencionó que todos los ciclos son equivalentes y con la
estructura if-else, puedes modelar un switch-case anidando if´s.
Cierre de la unidad
En los libros de Joyanes, L., & Zohanero, I. (2005), López. L. (2005) y Levine G.
(2001) se encuentran disponibles más ejercicios que puedes realizar para
practicar.
Fuentes de consulta