FPR_U2_Contenido

Vista previa del material en texto

Ciencias Exactas Ingeniería y Tecnología 
Primer Semestre 
 
 
Programa de la asignatura: 
Fundamentos de programación 
 
 
Unidad 2. Introducción al lenguaje C 
 
 
 
 
 
Universidad Abierta y a Distancia de México 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 2 
Índice 
Unidad 2: introducción al lenguaje C ............................................................................................... 3 
Presentación de la unidad ....................................................................................................................... 3 
Propósitos ............................................................................................................................................................. 3 
Competencia específica ............................................................................................................................ 4 
Logros………………….……………………………………………………………………………………………………………………………..4 
2.1. Componentes de un programa en lenguaje c................................................................... 5 
2.1.1. Instrucciones ........................................................................................................................................... 8 
2.1.2. Palabras reservadas ........................................................................................................................... 9 
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 ....................................................................................................................... 22 
2.4.2. Evaluación de expresiones ....................................................................................................... 25 
2.5. Bibliotecas y funciones.................................................................................................................... 27 
2.5.1. Funciones matemáticas .............................................................................................................. 28 
2.5.2. Funciones de entrada y salida ................................................................................................ 29 
2.6. Codificación de algoritmos .......................................................................................................... 30 
2.7. Estructuras de control .................................................................................................................... 40 
2.7.1. Estructuras selectivas ..................................................................................................................... 41 
2.7.2. Estructuras repetitivas ................................................................................................................. 59 
2.7.3. Estructuras anidadas .................................................................................................................... 79 
Cierre de la unidad ...................................................................................................................................... 83 
Fuentes de consulta ................................................................................................................................... 81 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 3 
 
Unidad 2: Introducción al lenguaje C 
 
Presentación de la Unidad 
 
 En esta unidad hablaremos sobre la forma en que se 
crean programas en el lenguaje de programación C, 
desarrollado por Dennis M. Ritche en el año de 1972, en 
los laboratorios Bell de la AT&T, y que posteriormente 
fue estandarizado por un comité del ANSI (por sus siglas 
en Inglés American National Standard Institute) dando 
lugar al ANSI C, a través del cual se garantiza que cualquier programa creado 
bajo este estándar pueda ser ejecutado en cualquier computadora (Kernighan 
y Ritchie, 1991). 
 
Los elementos básicos del lenguaje de programación C son: tipos de datos, 
variables y constantes, operadores lógicos y aritméticos, funciones de manejo 
de datos, entre otras funciones. 
 
 
Propósitos 
 
Al finalizar la unidad podrás: 
• Distinguirás la estructura de un programa en lenguaje C. 
• Declararás las variables y constantes que se utilizan en un programa en 
lenguaje C 
• Codificarás expresiones matemáticas en lenguaje C. 
• Utilizarás la colección de funciones (biblioteca) estándar del lenguaje C. 
• Utilizarás un entorno de trabajo del lenguaje C para escribir, compilar y 
ejecutar programas escritos en lenguaje C. 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 4 
• Construirás expresiones lógicas para modelar situaciones reales. 
• Diseñarás algoritmos para resolver problemas que impliquen la toma de 
decisiones, utilizando estructuras selectivas. 
• Diseñarás algoritmos para resolver problemas que requieran el uso de 
estructuras repetitivas. 
• Codificarás en lenguaje C algoritmos estructurados. 
 
 
Competencia específica 
 
 
Utilizar el lenguaje de programación C para implementar 
algoritmos secuenciales que permitan resolver problemas 
mediante la aplicación estructurada de los diversos elementos de 
programación y la utilización de estructuras de control selectivas y repetitivas. 
 
 
 
Logros 
• Identificar los tipos de datos, bibliotecas y funciones empleados en DevC++ 
• Identificar los beneficios de los algoritmos secuenciales. 
• Codificar un programa en DevC++ declarando las variables y constantes con 
base en bibliotecas y funciones para después compilarlo y ejecutarlo. 
 
 
 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 5 
 
2.1. Componentes de un programa en lenguaje C 
 
En general, “un programa es una secuencia de instrucciones mediante las 
cuales se ejecutan diferentes acciones de acuerdo con los datos que se estén 
procesando (López, 2005)”. 
 
En la unidad 1 se explicó que un programa puede ser ejecutado por una 
computadora solamente si está escrito en lenguaje de máquina, pero existen 
lenguajes de programación, que son fáciles de entender para los seres 
humanos, mediante los cuales se pueden escribir programas más legibles 
conocidos como programas fuente–en lenguaje C los programas fuente tiene 
extensión .c–, que son traducidos a lenguaje de máquina mediante 
compiladores o traductores. En el caso de C es un lenguaje compilado, por lo 
que se genera un programa ejecutable con extensión .exe, que puede ser 
ejecutado cada vez que se desee sin necesidad de volver a compilar el 
programa fuente, a menos que se realice algún cambio. 
 
De acuerdo con su creador, un programa fuente en lenguaje C, cualquiera que 
sea su tamaño, consta de funciones y variables. Una función contiene un 
conjunto de instrucciones, también llamadas preposiciones o enunciados, que 
especifican las operacionesque la computadora debe realizar; en tanto, las 
variables son los espacios de memoria donde se almacenan los valores 
utilizados en dichas operaciones (Kernighan y Ritchie, 1991, p. 6). 
 
Uno de los componentes principales de un programa en lenguaje C, es la 
colección de funciones o biblioteca, la cual hace referencia a un conjunto de 
subprogramas que forman parte del lenguaje, es decir “los programas en C 
usan siempre funciones de propósito general que están almacenadas en una 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 6 
biblioteca. Ejemplos de estas funciones son las de impresión en pantalla, la 
lectura del teclado, matemáticas, etcétera” (Muñoz y Palacios, 2006, p.13) 
 
Por convención y con el fin de aprender cómo funciona un nuevo lenguaje, el 
primer programa que se escribe por lo general es “hola mundo”, así que a 
continuación se muestra cómo se implementa este programa en lenguaje C. 
 
/*Directivas de preprocesador*/ 
#include<stdio.h> 
 
/* Definición de función 
Principal */ 
main( ) 
{ 
printf(“Hola mundo… \n”); 
} 
 
Ejemplo de programa hola.c 
 
Código en lenguaje C Descripción 
/*Directivas de 
preprocesador*/ 
 
El texto que se encuentra entre los signos /* */ 
son comentarios largos. Los comentarios 
sirven para documentar o describir las líneas de 
código subsecuentes y no son instrucciones 
que interprete la computadora. 
 
#include<stdio.h> De todas las bibliotecas del lenguaje C en esta 
instrucción se está indicando que la librería que 
se requiere utilizar es la biblioteca básica de 
entrada y salida. 
stdio 
 
std: estándar 
 
i: input 
 
o: output 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 7 
Es una (entre otras) instrucción especial que 
indica las directivas del preprocesador antes de 
la compilación del programa, se distingue 
porque inicia con el símbolo gato “#”, en este 
caso, esta instrucción le indica al compilador 
que debe incluir la información que está 
definida en el archivo de biblioteca stdio.h, 
en el cual se encuentran todas las funciones de 
salida y entrada, como printf. 
/* Definición de función 
Principal */ 
Es un comentario que describe la función 
principal del programa. 
main( ) 
{ 
printf(“Hola mundo… \n”); 
} 
Definición de función Principal del programa. 
Donde: 
Main(): La palabra main seguida de 
paréntesis es la función principal que siempre 
debe aparecer en algún lugar del programa ya 
que es el punto desde el cual se inicia la 
ejecución del mismo. 
{ } : Las instrucciones que corresponden al 
cuerpo de la función van encerradas entre 
llaves de agrupamiento las cuales indican el 
inicio y fin de la misma. 
 
Printf: es una función que se ejecuta o llama 
al nombrarla, es decir, escribiendo su nombre y, 
dentro de los paréntesis, se menciona la lista de 
argumentos, separados por comas. En otras 
palabras, los argumentos son los valores que 
una función necesita para realizar la tarea que 
tiene encomendada. En este ejemplo, esta 
función tiene como finalidad imprimir la 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 8 
cadena de caracteres que recibe como 
parámetro; en este caso el texto “Hola mundo”. 
 
\n: es una secuencia de caracteres que realiza o 
inserta un salto de línea. 
 
“Hola mundo…” : el texto que se encuentra 
entre comillas al dispositivo de salida básico 
que en este caso es el monitor “Hola mundo”. 
 
 
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. 
 
 
 
2.1.1. Instrucciones 
 
Una instrucción o enunciado en lenguaje C se puede definir como una 
expresión que tiene alguna consecuencia, generalmente la consecuencia se 
ve reflejada en el cambio del valor que está almacenado en las variables. De 
acuerdo con su estructura sintáctica se pueden clasificar en dos tipos: simples 
y compuestas. 
 
Las instrucciones simples se distinguen porque terminan con punto y coma “;”. 
La sintaxis es: 
<instrucción>; 
 
Como ejemplo de instrucciones simples tenemos la declaración de variables, 
la llamada de funciones y la asignación. 
int x; 
 x = 2*y; 
printf(“Hola”); 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 9 
 
En cambio, las instrucciones compuestas son un conjunto de instrucciones que se 
escriben entre llaves “{…}”, para formar lo que conocemos como un bloque de 
instrucciones. 
La sintaxis es: 
{ 
<instrucción>; 
<instrucción>; 
… 
<instrucción>; 
} 
 
2.1.2. Palabras reservadas 
 
Las palabras reservadas de cualquier lenguaje de programación se llaman así 
porque tienen un significado especial para el compilador, el lenguaje C tiene 
32 palabras reservadas (27 fueron definidas en la versión original y cinco 
añadidas por el comité del ANSI: enum, const, signed, void y volatile), todas ellas 
escritas con minúsculas.1 
 
En la siguiente tabla se muestran todas las palabras claves o reservadas de lenguaje 
C. 
asm continue float register struct volatile 
auto default for return switch while 
break do goto short typedef 
case double if signed union 
char else int sizeof unsigned 
const enum long static void 
Palabras reservadas de C 
 
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 
 
UNADM | DCEIT | FPR 10 
2.1.3. Estructura general de un programa 
 
Si observas el programa hola.c, la primera instrucción es la directiva al 
preprocesador, seguida de la función main y las instrucciones que la integran. 
Esta estructura corresponde a los programas más simples, pero es similar a la 
de cualquier programa en C. La forma general de cualquier programa en C es 
la siguiente: 
<instrucciones para el preprocesador> 
<declaraciones globales> 
<tipo_devuelto> main(<lista de parámetros>) 
{ 
<lista de instrucciones> 
} 
Y como se ha mencionado, se pueden incluir comentarios en cualquier parte 
del código. A continuación, se presenta un programa que calcula el área de 
una circunferencia dada la medida de su radio. 
 
/* Directivas del procesador (bibliotecas) */ 
 #include<stdio.h> 
 
/* Declaraciones globales */ 
const float PI = 3.1416; 
 
/* Función Principal */ 
main( ) 
{ 
 /* Declaraciones de variables locales de la 
función main*/ 
float radio, area; 
 
printf("Calcula el área de una circunferencia\n"); 
printf(" Ingresa el radio: "); 
scanf("%f", &radio); 
area = PI * radio * radio; 
printf("Area = %.2f",area); 
getchar(); 
getchar(); 
} 
Ejemplo de programa areaCircunferencia.c 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 11 
 
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. 
 
 
Ejecución del programa areaCircunferencia.c utilizando Dev-C++ 
 
 
 
2.2. Tipos de datos 
 
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 creaun 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. 
 
 
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 
 
UNADM | DCEIT | FPR 12 
En general, los tipos de datos que existen, independientemente de un 
lenguaje de programación, se pueden clasificar de la siguiente forma: 
 
Simples 
❖ Numéricos 
Enteros 
Decimales 
❖ Lógicos (verdadero o falso) 
❖ Alfanuméricos (caracteres) 
Estructurados 
❖ Arreglos 
Unidimensionales 
Multidimensionales 
❖ 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: 
 
Tipo Descripción Ejemplo 
char 
Su tamaño equivale a 
ocho bits, capaz de 
contener un carácter del 
conjunto de caracteres 
ASCII. 
´a´, 
´C´, ´3´ 
int 
Un entero, normalmente 
ocupa mínimo 16 bits, 
pero su tamaño es según 
la máquina en que se 
ejecute. 
 
1024, 
-258 
Float 
Número de punto 
flotante de 
precisión normal. 
10.5, 
-11.6 
Double 
Punto flotante de doble 
precisión 
 
 0.00045, 
-0.55236 
Tipos básicos en C (Cairó, 2006). 
 
 
Es posible aumentar o disminuir la capacidad de representación de los 
números utilizando los modificadores long, short y unsigned. De esta manera las 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 13 
combinaciones que se ajustan al estándar ANSI, junto con sus rangos mínimos, 
son: 
 
Tipo Bits Rango 
Char 8 -127 a 127 
unsigned char 8 0 a 255 
signed char 8 -127 a 127 
Int 16 -32767 a 32767 
unsigned int 16 0 a 65535 
signed int 16 -32767 a 32767 
short int 16 -32767 a 32767 
unsigned short int 16 0 a 65535 
signed short int 16 -32767 a 32767 
long int 32 -2147483647 a 2147483647 
signed long int 32 -2147483647 a 2147483647 
unsigned long int 32 0 a 4294967295 
Float 32 seis dígitos de precisión 
Double 64 diez dígitos de precisión 
long double 64 diez dígitos de precisión 
Tipos básicos y modificadores 
 
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. Variables y constantes 
 
Las variables y las constantes en lenguaje C se utilizan para almacenar valores, 
la diferencia que existe entre ellas es que el valor almacenado en una variable 
puede ser modificado en cualquier instante del programa en tanto que las 
constantes no pueden modificarse. 
 
 
Formalmente, una variable es un espacio de memoria que tiene asignado un 
nombre (también llamado identificador) y se utiliza para almacenar un valor 
que puede ser modificado durante la ejecución de un programa, a este valor 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 14 
que se encuentra almacenado en una variable en un momento dado se le 
llama estado de la variable. Por lo contrario, una constante es un dato cuyo 
valor se establece en tiempo de compilación y no pueden cambiar durante la 
ejecución del programa. 
 
Existen dos tipos de constantes: literales y simbólicas. Las segundas, al igual 
que las variables, también tienen asignado un nombre. A lo largo de esta 
sección descubrirás cómo puedes construir variables y constantes en lenguaje 
C, así que lo primero será listar las reglas que debes seguir para nombrarlas. 
 
2.3.1. Identificadores 
 
En lenguaje C hay una serie de restricciones en cuanto a los nombres o 
identificadores, ya sea de variables, constantes o funciones. Éstas son: 
Los identificadores se integran por letras y dígitos, pero es necesario que el 
nombre siempre comience con una letra, por ejemplo: enteroA, arco3, S184. 
a) No puede contener caracteres especiales, por ejemplo, acentos (á,í), la 
letra eñe (Ñ), gato (#), guión (-). El carácter de subrayado “_”es el único 
carácter especial que puede utilizarse, generalmente se usa para darle 
una mejor legibilidad al nombre de una variable. Por ejemplo: entero_A, 
area_Circulo, i_elemento. 
b) El lenguaje C distingue entre letras mayúsculas y minúsculas, esto 
significa que los siguientes identificadores son distintos: area, Area, 
AREA. 
c) No pueden contener espacios en blanco. 
d) No pueden ser palabras reservadas. 
Aunque no es una regla, se recomienda que los identificadores sean 
significativos, es decir, que el nombre indique qué dato se está almacenando 
ahí. 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 15 
Ejemplo del área del círculo: 
 
1) Se requiere una variable para almacenar el radio de un círculo 
Las opciones sugeridas son: radio, radioCirculo, radio_circulo. 
2) Se requiere un identificador para una variable que almacene el 
promedio de ventas anuales de una tienda departamental. 
Opciones sugeridas: promedioVentas, prom_Ventas, promAnual. 
3) Almacenar el número telefónico de una persona. 
Opciones sugeridas: tel, telefono. 
 
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. 
 
2.3.2. Declaración e inicialización de variables 
 
La declaración de una variable es una instrucción que proporciona información 
de la variable al compilador, para que éste reserve en memoria el espacio 
adecuado y la referencia (identificador) para tener acceso a ella. Las 
declaraciones en general tienen la siguiente sintaxis: 
 
<tipo><identificador>; 
 
Donde <tipo> se refiere a un tipo básico de C y el <identificador> se refiere al 
nombre con el cual se identificará el espacio de memoria reservado, puede ser 
cualquier nombre siempre y cuando se respeten las reglas vistas previamente. 
Veamos los siguientes ejemplos: 
 
int edad; /* declara una variable de tipo entero con el 
identificador edad*/ 
float area; /* declara una variable de tipo float a la cual se 
identificará por area*/ 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 16 
También es posible declarar una lista de variables de un mismo tipo separando 
los nombres con comas “,” 
 
<tipo><identificador1>, … , <identificadorN>; 
 
Podemos ver un ejemplo de este tipo de declaración en Ejemplo de programa 
areaCircunferencia.c en el cual se calcula el área de una circunferencia, 
cuando declaramos las variables locales a la función main: 
 
float radio, area; 
 
Siempre es posible asignar un valor inicial a las variables cuando las 
declaramos, a esta operación se conoce como inicialización. La sintaxis es: 
 
<tipo><identificador>=<valor>; 
 
Del mismo modo, podemos inicializar varias variables al mismo tiempo: 
 
<tipo><identificador1> = <valor1>, … , <identificadorN> = <valor2>; 
 
Para ilustrar esto, se presentan las siguientes instrucciones: 
 
int edad = 18; 
float radio = 3.0, area = 0.0; 
 
 
En la tabla siguiente se muestra una representación gráfica de estas 
declaraciones e inicializaciones: la columna de Dirección representa la 
dirección física de los registros en la memoria RAM y si ha sido asignada a una 
variable también se escribe su identificador; en contenido se muestra el dato 
que está almacenado en dicha dirección. El estado de una variable (memoria) 
hace referencia al valor que hay almacenado en un momento determinado. 
 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 17 
MEMORIA 
Dirección Contenido Dirección Contenido 
01 
51 
radio 
3.0 
02 
edad 
18 
52 
 
 
03 53 
04 
54 
area 
0.0 
05 55 
… 56 
Memoria y declaración e inicialización de variables.De lo anterior tenemos que: a la variable edad le corresponde la dirección de 
memoria 02 y su estado es 18; a la variable radio le corresponde la dirección 51 y su 
estado es 3.0; y, por último, a la variable area le corresponde la dirección 54 y 
el estado es 0.0. 
 
 
2.3.3. Tipos de constantes 
 
Las constantes son expresiones con un significado invariable, en un programa 
puede haber dos tipos de constantes: literales y simbólicas (Cairó, 2006). 
 
Las constantes literales son valores de un determinado tipo escritos 
directamente en un programa y pueden ser de los siguientes tipos: 
 
a) Constantes numéricas, que son números representados en sistema 
decimal, algunas veces se estila escribir una letra que indique el tamaño 
o tipo de la constante numérica: 
 
Enteros: Por ejemplo 123, 2006, -38… 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 18 
Enteros Largos: Se consideran números enteros que superan un entero 
(int) generalmente valores mayores a 32,000; se le agrega los sufijos l ó 
L por ejemplo: 123456789L. 
 
Enteros sin Signo: Aquí se define que el valor de la constante se va a 
considerar como un número positivo o mayor a cero, en estos casos se 
agrega el sufijo U o u así por ejemplo podemos escribir: 123456789LU. 
 
Flotantes: Los valores numéricos que impliquen precisión decimal se 
pueden escribir de dos formas, la primera sería: 14324.983 o 3.1416. 
También se puede representar en representación exponencial (e-n), por 
ejemplo: 1.1434E2 o 1.1432e-5. También se ocupan los sufijos f o F y l o L 
para especificar los tipos double. 
 
Como puedes observar, las constantes reales con representación 
exponencial, tienen como valor una parte entera o real en forma decimal, 
seguida por la letra E, seguida de una constante entera, que se interpreta 
como exponente de la base 10. 
 
b) Constantes caracter, que se representan internamente por el lenguaje C 
como un número entero corto (short int). Una constante caracter 
siempre debe ir entre apóstrofes, por ejemplo: ‘x’, ‘A’. 
 
También existen constantes caracter que aparentan ser compuestas, pero 
sólo son representaciones de caracteres de formato o caracteres especiales, y 
en C se les conoce como secuencias de escape. A continuación, observa la 
combinación de caracteres. 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 19 
‘\n’ Salto de línea 
‘\t’ Tabulador 
‘\b’ Espacio hacia atrás 
‘\f’ Salto de página 
‘\”’ Comillas 
‘\\’ Barra invertida 
Secuencias de escape 
 
c) Constantes cadena, que son una secuencia de caracteres entre comillas, 
incluyendo secuencias de escape, por ejemplo: “hola”, “hola mundo 
\n”. 
 
Por otro lado, las constantes simbólicas representan datos permanentes que 
nunca cambian. Ahondaremos en este tema en la siguiente sección. 
 
Las constantes de este tipo son representadas por un nombre (simbólico) en 
el código del programa. Del mismo modo en que ocurre con las constantes 
literales éstas no pueden cambiar su valor, sin embargo para utilizar el valor 
constante se utiliza el nombre simbólico que le ha sido otorgado. 
 
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. 
 
 
2.3.4. Declaración de constantes 
 
En C existen dos formas de declarar una constante simbólica. La primera es 
utilizando la directiva de preprocesador #define, la cual asocia un identificador 
a un valor constante, sin reservar espacio en memoria, por lo que no podemos 
decir que se declara, sólo se define (Cairó, 2006). La sintaxis general es la 
siguiente: 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 20 
 
 
#define<identificador><valor_constante> 
 
Por ejemplo: 
 
#define PI 3.1416 
 
Con esta instrucción cada vez que en el programa se escriba el identificador PI 
éste será sustituido por el compilador con el valor de 3.1416 (no se almacena el 
valor 3.1416 en ningún espacio de memoria sólo se hace una sustitución textual 
en el momento de compilación). 
 
La segunda forma de declarar una constante simbólica es reservando espacio 
de memoria que tenga la restricción de sólo lectura, para impedir que el valor 
sea cambiado, en este caso si la declaramos. La sintaxis general es similar a la 
forma de declarar una variable sólo que se antepone al tipo la palabra 
reservada const y es obligatorio asignar el valor. 
 
const<tipo><identificador> = <valor_constante>; 
Por ejemplo: 
 
const float PI = 3.1416 ; 
 
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. 
 
Se recomienda escribir el nombre de una constante con letras mayúsculas 
para diferenciarlas de las variables, pero las reglas son exactamente las mismas 
que para los identificadores de las variables. 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 21 
 
 
2.4. Expresiones matemáticas 
 
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. 
 
Se dividen en dos clases de acuerdo al tipo de datos que devuelven cuando 
son evaluadas: expresiones aritméticas cuando el resultado de la evaluación es 
un número y expresiones booleanas cuando el resultado de la evaluación es 
un valor booleano (verdadero o falso). En este punto es importante destacar 
que el modo en que el lenguaje C maneja los valores booleanos es por medio 
de valores enteros: cero equivale a falso y cualquier entero distinto de cero 
representa verdadero. 
 
Las expresiones matemáticas permiten modelar situaciones reales, por 
ejemplo, mediante las expresiones aritméticas podemos modelar la forma de 
calcular el área de cualquier figura, también podemos representar la forma de 
calcular las raíces de un polinomio de segundo grado, o calcular el monto de 
una venta, etc. En cambio, las expresiones booleanas son la base para construir 
programas que pueden tomar decisiones. 
 
Veamos los siguientes ejemplos: 
 
Ejemplos de expresiones matemáticas: 
 
a) La hipotenusa es igual a la raíz cuadrada de la suma de los cuadrados de 
catetos. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 22 
Expresión aritmética: 𝑐 ← √𝑎2 + 𝑏2 
Codificación en C: c =sqrt(a*a + b*b); 
 
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. 
 
Expresión booleana: 𝑥𝑚𝑜𝑑 2 = 0 
Codificación en C: x % 2 == 0 
 
En el siguiente subtema se presentan los operadores básicos del lenguaje C, 
tanto aritméticos como booleanos. 
 
 
2.4.1. Tipos de operadores 
 
Los operadores son palabras o símbolos que permiten realizar operaciones con 
los datos de un programa, para cada tipo de datos hay una serie de operadores 
definidos. 
 
Entre todos los operadores se distingue el operador de asignación “=”, que se 
puede leer como “guarda un valor en la variable indicada”, el valor puede ser 
una constante literal o el resultado de una expresión. Cabe señalar que este 
operador en pseudocódigo o diagrama de flujo lo hemos representado con 
una flecha apuntado hacia la izquierda ←. 
 
Veamos algunos ejemplos: 
radio = 3.0; /* modifica el estado de la variable radio con 
el valor 3.0*/ 
area = PI * radio *radio; /* modifica el estado de la 
variable por el resultado de evaluar la expresión PI * radio 
* radio */ 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 23 
 
Losoperadores 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 
 
En C también existen los operadores de incremento “++” y decremento “--“, 
éstos tienen el efecto de aumentar o decrementar en una unidad el valor de 
una variable, supongamos que estamos trabajando con la variable x: 
 
x++;/* equivale a hacer: x = x + 1;*/ 
x--;/* equivale a hacer: x = x – 1;*/ 
 
Por ejemplo, si el valor de x es 5 el resultado de aplicar ++ y -- es: 
 
x++; → 6 
x--; → 4 
 
Los operadores que permiten construir expresiones booleanas son: 
• Operadores relacionales, que manipulan expresiones aritméticas y son: 
“>” (mayor que), “<” (menor que), “>=” (mayor o igual), “<=” (menor o 
igual), “==” (igual), “!=” (distinto) 
• Operadores booleanos, también llamados lógicos, manipulan 
únicamente expresiones booleanas y son: “!” (negación), “||” (disyunción) 
y “&&” (conjunción). 
 
Observa que el operador de igualdad se escribe con dos símbolos de igualdad 
seguidos (==). El error más común es escribir una comparación con un sólo 
símbolo de igualdad, recuerda que (=) es el operador de asignación y su 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 24 
significado es totalmente distinto. En cuanto a los operadores booleanos, su 
significado es el siguiente: 
 
Negación“!”, es un operador unario que cambia el valor de verdad de la 
expresión a la cual se le aplica. Por ejemplo, si el valor de verdad de expresión 
es verdadero entonces devuelve falso, y viceversa. Por ejemplo, si x=2, y=3, z=5. 
 
!(z > x ) → !(5 > 2 )→ !(1)→ 0 (falso) 
!(x > y ) → !(2 > 3 )→ !(0)→ 1 (falso) 
 
En pseudocódigo o diagrama de flujo se representa con la palabra en inglés 
NOT. 
 
• Conjunción“&&”, es un operador binario que se evalúa como verdadero 
sólo cuando las dos expresiones involucradas son verdaderas, en caso 
contrario devuelve falso. Por ejemplo, si evaluamos las siguientes 
expresiones en el estado x=2, y=3, z=5. 
(x>y) && (z>y) → (2 > 3) && (5 > 3) → 0&&1 → 0 (falso) 
!(x > y) && (z>y) →!(2 > 3) && (5 > 3) → ! (0) &&1 → 1&&1 → 1 
(verdadero) 
 
En pseudocódigo y diagrama de flujo se representa con la palabra en inglés 
AND. 
• Disyunción“||”, también es un operador binario que devuelve 
únicamente devuelve falso si los dos operadores son falsos, en caso 
contrario devuelve verdadero. Nuevamente, tomemos el mismo estado 
de las variables x=2, y=3, z=5. 
(x>y)||(z>y) →(2>3)||(5>3) → 0||1 → 1 (verdadero) 
(x>y)||(y>z) →(2>3)||(3>5) → 0||0 → 0 (falso) 
 
En pseudocódigo y diagrama de flujo se representa con la palabra en inglés 
OR. 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 25 
 
En C existen otro tipo de operadores, sin embargo, su estudio no está 
considerado dentro de los objetivos de este curso por lo que no los 
revisaremos, pero si deseas saber más, puedes consultar a Joyanes y Zahonero 
(2005). 
2.4.2. Evaluación de expresiones 
 
La evaluación de las expresiones depende de tres cosas, principalmente, el 
estado de las variables que aparecen en la expresión, el significado de los 
operadores y su precedencia. Esta última se refiere a la prioridad de los 
operadores, es decir, el orden en el que se evalúan, eliminando con esto la 
ambigüedad de las expresiones, por ejemplo, si tenemos la expresión (Malva, 
Et al., 2005): 
2 + 3 * 5 
 
Podríamos evaluarla de dos diferentes formas: La primera es hacer primero la 
suma 2+3 (=5) y después multiplicar el resultado por 5. De tal manera 
obtendríamos como resultado final 25. Otra manera sería realizar primero la 
multiplicación 3*5 (=15) y sumar el resultado a 2, obteniendo 17 como resultado 
final. Pero sabemos que en matemáticas primero se realiza la multiplicación y 
después la suma, en otras palabras, tiene mayor prioridad la multiplicación que 
la suma. Por lo tanto, el resultado correcto de la expresión 2 + 3 * 5 es 17. En la 
siguiente tabla se muestra la precedencia de operadores de lenguaje C que se 
han presentado. 
Operadores Prioridad 
( ) Mayor 
-(unario), ++, -- 
*, /, % 
+, - 
<, >, >= , <= 
==, != 
&&, || 
= Menor 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 26 
Prioridad de operadores 
 
Los operadores que se encuentran en el mismo nivel de precedencia se 
ejecutan de izquierda a derecha según aparecen en la expresión. 
 
Veamos el siguiente ejemplo: 
 
Ejemplo de evaluación de expresiones: Dada la siguiente expresión 
matemática para convertir grados centígrados (C) a su equivalente Fahrenheit 
(F), 
𝐹 = 
9
5
𝐶 + 32 
Su codificación en C es: 
F= (9.0/5.0)*C +32; 
 
Se escribe 9.0 y 5.0 para que la división devuelva un número flotante, de lo 
contrario la división será entera. En este caso las variables F y C, deben ser 
declaradas como float. 
 
Evaluando, paso a paso, la expresión en el estado de la variable C = 30 tenemos: 
 
 
Expresión actual Estados de las variables 
F= (9.0/5.0)*C +32; 
C F 
30 ¿? 
 
F= (9.0/5.0)*30 +32; Igual al anterior 
F= 1.8*30 +32; Igual al anterior 
F= 54 +32; Igual al anterior 
F= 86; 
C F 
30 86 
 
 
Observa que el único operador que cambia el estado de una variable es el de 
asignación “=”. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 27 
Ejemplo de evaluación de expresiones: Ahora evaluemos la expresión: 
 
(x % 2 == 0) 
 
 
Considerando que el estado de la variable x=24 
 
Expresión actual Estados de las variables 
x % 2 == 0 
 
X 
24 
 
0 == 0 Igual al anterior 
1 Igual al anterior 
 
En este caso la evaluación de la expresión no afecta el estado de la variable, 
esto es porque no contiene ningún operador de asignación, sin embargo, 
podemos decir que el resultado de su evaluación es verdadero. 
 
2.5. Bibliotecas y funciones 
 
El lenguaje C en realidad es un lenguaje reducido en comparación con otros 
lenguajes de programación, por ejemplo, no tiene instrucciones de estrada y 
salida, y tampoco cuenta con operadores o funciones para calcular la raíz 
cuadrada de un número o su potencia, entre otras. Sin embargo, para 
compensar esto el lenguaje C ofrece un vasto conjunto de bibliotecas de 
funciones, que para fines prácticos se pueden considerar como parte de C. 
Cabe mencionar que también es posible definir nuevas bibliotecas, sin 
embargo, el lenguaje C tiene definidas diversas funciones de uso frecuente, 
que para fines de este curso son más que suficiente, por lo que este tema no 
se estudiará en esta ocasión.3 
 
 
3Si deseas más información se te recomienda consultar (Joyanes & Zohanero, 2005). 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 28 
Las funciones que más se utilizan están agrupadas en bibliotecas estándar, 
declaradas como archivos de cabecera, de tal manera que para utilizarlas se 
debe incluir en el archivo utilizando la directiva #include seguida del nombre 
del archivo encerrado entre “<>” 
 
Las bibliotecas estándar que usaremos en este curso son: 
• stdio.h en esta biblioteca se encuentran definidas las funciones estándar 
de entrada y salida –que representan la tercera parte de la biblioteca–, 
por ejemplo, declara la función printf que sirve para imprimir datos en 
pantalla y scanf que se utiliza para leer de datos ingresados mediante el 
teclado. 
• stdlib.h incluye funciones para conversión numérica, asignación de 
memoria y tareas similares, llamadas funciones de utilería. En esta 
biblioteca se declara la función system mediante la cual se envían 
mensajes al sistema operativo para que ejecute una tarea. 
• math.h declara funciones matemáticas, como la función sqrt que calcula 
la raíz cuadrada de un número. 
• ctype.hdeclara funciones para prueba de clasificación de caracteres, por 
ejemplo, si es un dígito o un carácter. 
 
Observa que todas las bibliotecas estándar tienen extensión “.h”4 
 
 
2.5.1. Funciones matemáticas 
 
La siguiente tabla muestra algunas de las funciones predefinidas en lenguaje 
C declaradas en la biblioteca math.h. 
 
 
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 
 
UNADM | DCEIT | FPR 29 
Función Descripción Argumento Resultado Ejemplo 
sqrt(x) Raízcuadrada Flotante flotante sqrt(900) = 90 
exp(x) Function exponencial Flotante flotante exp(2.0)= 
2.718282 fabds(x) Valor absoluto entero o 
flotante 
entero o 
flotante 
fabs(-5) = 5 
log(x) Logaritmoneperiano de x entero o 
flotate 
flotante log(0.5) = -0.693 
Log10(x) logaritmo decimal de x entero o 
flotante 
flotante Log10(0.5) = -
0.301 floor(x) Redondeohaciaabajo Flotante entero floor(6.5)=6 
ceil(x) Redondeohaciaarriba Flotante entero ceil(6.5)=7 
sen(x) seno de x entero o real flotante sen(0.5) = 0 
pow(x,y) Devuelve la potencia de x 
elevada a la y 
entero o 
flotante 
flotante pow(5,2) = 25 
cos(x) coseno de x flotante flotante cos(0.5) = 1 
sin(x) seno de x flotante Flotante sin(0.0) = 0 
tan(x) Tangente de x flotante Flotante tan(0.0) = 0 
 Funciones matemáticas 
 
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 * radio * radio; 
 
Se puede codificar de la siguiente manera: 
 
area = PI * pow(radio,2); 
 
 
2.5.2. Funciones de entrada y salida 
 
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: 
 
printf(<cadena_de_control>, <lista_de_identificadores>); 
 
Donde <cadena_de_control> representa el mensaje de texto que se desea 
desplegar en el monitor y siempre tiene que ir en comillas, opcionalmente 
puede incluir secuencias de escape o especificadores de control, y 
<lista_de_identificadores> es una lista con los identificadores de las variables 
o las expresiones que serán desplegadas, separadas por comas. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 30 
Las secuencias de escape, se expusieron anteriormente, los especificadores de 
conversión se utilizan para imprimir valores dentro de la cadena de control 
especificados por una variable, una constante o una expresión. En la siguiente 
tabla se muestran los que más se utilizan. 
 
Especificador Acción 
%d Insertar un entero (int) 
%i Insertar un entero tipo (int) 
%ld Insertar un entero tipo (long) 
%f 
Insertar un número flotante 
tipo (float) 
%lf 
Insertar un número de tipo 
(double) 
%c Insertar un caracter (char) 
%s Insertar una cadena(char [ ]) 
Especificadores de conversión 
 
 
 
 
Ejemplo de datos de entrada y salida 
 
Suponiendo que el estado de las variables es radio=3 y área=28.27, 
 
printf(“El área del círculo con radio %d es %f \n”,radio,area); 
 
La salida de la instrucción anterior sería: 
 
El área del círculo con radio 3 es 28.27 
 
Observa que se imprime el texto, pero en vez de imprimir el especificador de 
conversión %d se imprime el valor de la primera variable que es radio y en el 
lugar del especificador %f se imprime el valor del siguiente argumento que es 
la variable area. 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 31 
Ahora, sí tenemos la instrucción: 
 
printf(“El perímetro es %.2f \n”, PI*2*radio); 
 
La salida es: 
 
El perímetro es 18.85 
 
En este caso en el lugar del convertidor %.2f se imprime el resultado de evaluar 
la expresión PI*2*radio que es el segundo argumento, el número .2 que 
aparece en el convertidor indica que sólo deben imprimirse dos decimales. 
 
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. 
 
La sintaxis de esta función es: 
 
scanf(<cadena_de_control>,<lista_de_direcciones_de_variables>); 
 
Donde <cadena_de_control> es una cadena con los códigos que controlarán la 
forma como se recibirán los datos desde teclado y la 
<lista_de_direcciones_de_variables> es una lista con las localidades de 
memoria de las variables donde se almacenarán los datos que el usuario del 
programa introduzca a través del teclado. 
 
Dos observaciones importantes: en la especificación de la cadena de control se 
utilizan los mismos especificadores de conversión que para la función printf 
encerrados entre comillas y en la lista de direcciones los identificadores de las 
variables, anteponiéndoles a cada uno un símbolo de amperson “&”, en el 
mismo orden que los especificadores de tipos que les corresponden. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 32 
 
Ejemplo de recepción de datos de entrada 
Suponiendo que se desea leer la base y la altura de un rectángulo y guardarlas 
en las variables de tipo int llamadas base y altura, de tal manera que el usuario 
ingrese los valores separados por una coma, digamos “5,2” entonces la 
instrucción sería: 
 
scanf(“%d,%d”, &base, &altura); 
 
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. 
 
 
2.6. Codificación de algoritmos 
 
Para resolver un problema, ejemplificaremos la codificación de algoritmos a 
través de la resolución del siguiente problema: 
 
Descripción del problema 
Se requiere un programa que se encargue de la venta de boletos en un cine. 
El sistema debe calcular el monto que se debe pagar por una cantidad 
determinada de boletos tomando en cuenta que el costo de cada boleto es de 
45 pesos. 
También se encargará de cobrar, es decir, dado el pago debe calcular el cambio 
indicando el tipo y número de billetes o monedas de cada denominación que 
devolverá. Para evitarse problemas de cambio, los ejecutivos de la empresa 
donde se exhiben las películas, han decidido no aceptar monedas de 
denominación menor a 1 peso y tampoco billetes de denominación mayor a 
500 pesos. También se debe suponer que siempre hay suficientes billetes y 
monedas de cualquier denominación para devolver el cambio. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 33 
Análisis: Los datos de entrada son el número de boletos (nboletos)5 y el 
monto del pago (pago), la salida del programa es el monto que se debe pagar 
por los boletos (total) y el monto del cambio (cambio), indicando el tipo y 
número de cada uno de los billetes o monedas que se devolverán. Notemos 
que el precio de los boletos siempre es el mismo, así que se puede declarar 
como una constante, llamémosla PRECIO. Así que para calcular el monto que 
el cliente debe pagar tenemos la siguiente fórmula: 
 
total = nboletos * PRECIO 
 
Y el monto del cambio se calcula con la siguiente fórmula: 
 
cambio = pago – total 
 
Para calcular cuántos billetes o monedas se tienen que devolver, se utilizarán 
los operadores de módulo y división. Por ejemplo, si el cambio es 360 se puede 
calcular el número de billetes de 100 dividiendo 360 entre 100, lo cual resulta 
ser 3 que corresponde al número de billetes, el resto del cambio es igual a 360 
módulo 100, en este caso es 60. 
 
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. 
 
Diseño del algoritmo: En la siguiente tabla se muestra el algoritmo que 
resuelveel problema. 
Constantes: 
PRECIO = 45 
 
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 
 
UNADM | DCEIT | FPR 34 
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 
Imprimir “El número de monedas de 5 pesos es”, 
cambio/5 
cambio = cambio módulo 5 
Imprimir “El número de monedas de 2 pesos es”, 
cambio/2 
cambio = cambio módulo 2 
Imprimir “El número de monedas de 1 peso es”, 
cambio 
Fin 
Ejemplo del algoritmo: ventaBoletos (pseudocódigo). 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 35 
Nota: Observa que no es necesario utilizar variables para el número de billetes 
o monedas de las diferentes denominaciones, pues sólo se utiliza una vez el 
resultado del cálculo así que se puede imprimir directamente el resultado del 
mismo. 
 
Para verificar que el algoritmo funciona, en la siguiente tabla se realiza una 
prueba de escritorio considerando que los datos de entrada son 5 boletos y el 
monto del pago son 500 pesos. En la primera columna aparece la instrucción 
que se ejecuta, en la siguiente el dato que suponemos se ingresa, después 
están las operaciones que se realizan en la ALU, en la cuarta columna se 
muestra los valores de las variables después de que se ha realizado la 
instrucción y en la última columna se indica el mensaje que se imprimirá en la 
pantalla, cuando sea el caso. Por otro lado, incluimos en la tabla de estado de 
la memoria la constante PRECIO sombreando el espacio correspondiente para 
indicar que no puede ser modificado. 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 36 
Instrucción 
Dato 
de 
entrada 
Operaciones 
Estado de la memoria 
(variables y constantes) 
Dato de salida 
Inicio - - 
PRECIO nBoletos total pago cambio 
45 - - - - 
 
- 
Imprimir 
“Proporciona el 
número de 
boletos”. 
- - 
PRECIO nBoletos total pago cambio 
45 - - - - 
 
Proporciona el 
número de 
boletos 
Leer nBoletos 
 
5 - 
PRECIO nBoletos total pago cambio 
45 5 - - - 
 
- 
total = 
nBoletos*PRECIO 
 
- 
total = 5*45 
=225 
PRECIO nBoletos total pago cambio 
45 5 225 - - 
 
- 
Imprimir 
“Proporciona tu 
pago” 
- - 
PRECIO nBoletos total pago cambio 
45 5 225 - - 
 
Proporciona 
tu pago 
Leer nBoletos 
 
500 - 
PRECIO nBoletos total pago cambio 
45 5 225 500 - 
 
- 
cambio = pago - 
total 
- 
cambio = 
500-225 = 
275 
PRECIO nBoletos total pago cambio 
45 5 225 500 275 
 
- 
Imprimir “Tu 
cambio es”, 
cambio. 
- - 
PRECIO nBoletos total pago Cambio 
45 5 225 500 275 
 
Tu cambio es 
275 
Imprimir “El 
número de 
billetes de $200 
es”, cambio/200 
- 275/200 = 1 
PRECIO nBoletos total pago Cambio 
45 5 225 500 275 
 
El número de 
billetes de 
$200 es 1 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 37 
cambio = cambio 
módulo 200 
- 
cambio = 
275 mod 
200 
=75 
PRECIO nBoletos total pago Cambio 
45 5 225 500 75 
 
- 
Imprimir “El 
número de 
billetes de $100 
es”, cambio/100 
- 75/100 = 0 
PRECIO nBoletos total pago Cambio 
45 5 225 500 75 
 
El número de 
billetes de 
$100 es 0 
cambio = cambio 
módulo 100 
- 
cambio = 
275 mod 100 
=75 
PRECIO nBoletos total pago Cambio 
45 5 225 500 75 
 
- 
Imprimir “El 
número de 
billetes de $50 
es”, cambio/50 
- 75/50= 1 
PRECIO nBoletos total pago Cambio 
45 5 225 500 75 
 
El número de 
billetes de $50 
es 1 
cambio = cambio 
módulo 50 
- 
cambio = 75 
mod 50 
=25 
PRECIO nBoletos total pago Cambio 
45 5 225 500 25 
 
- 
Imprimir “El 
número de 
billetes de $20 
es”, cambio/20 
- 25/50= 0 
PRECIO nBoletos total pago Cambio 
45 5 225 500 25 
 
El número de 
billetes de $50 
es 0 
cambio = cambio 
módulo 20 
- 
cambio = 
25 mod 20 
=5 
PRECIO nBoletos total pago Cambio 
45 5 225 500 5 
 
- 
Imprimir “El 
número de 
monedas de $10 
es”, cambio/10 
- 5/10= 0 
PRECIO nBoletos total pago Cambio 
45 5 225 500 25 
 
El número de 
monedas de 
$10 es 0 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 38 
cambio = cambio 
módulo 10 
- 
cambio = 5 
mod 10 
=5 
PRECIO nBoletos total pago Cambio 
45 5 225 500 5 
 
- 
Imprimir “El 
número de 
monedas de $5 
es”, cambio/5 
- 5/5= 1 
PRECIO nBoletos total pago Cambio 
45 5 225 500 5 
 
El número de 
monedas de 
$5 es 1 
cambio = cambio 
módulo 5 
- 
cambio = 5 
mod 5 
=0 
PRECIO nBoletos total pago Cambio 
45 5 225 500 0 
 
- 
Imprimir “El 
número de 
monedas de $2 
es”, cambio/2 
- 0/2= 0 
PRECIO nBoletos total pago Cambio 
45 5 225 500 0 
 
El número de 
monedas de 
$2 es 0 
cambio = cambio 
módulo 2 
- 
cambio = 0 
mod 2 
=0 
PRECIO nBoletos total pago Cambio 
45 5 225 500 0 
 
- 
Imprimir “El 
número de 
monedas de $1 
es”, cambio 
- - 
PRECIO nBoletos total pago Cambio 
45 5 225 500 0 
 
El número de 
monedas de 
$1 es 0 
Fin - - 
PRECIO nBoletos total pago Cambio 
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: 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 39 
 
/* 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); 
 
/*Calculamos el total de la venta*/ 
total = nBoletos*precio; 
printf("El total es *** %d pesos *** \n\n",total); 
 
/*Leemos el pago y calculamos el cambio*/ 
printf("Indique el monto de su pago: "); 
scanf("%d",&pago); 
 
/*Calculamos el cambio y lo devolvemos*/ 
cambio = pago - total; 
printf("\n\n El monto de su cambio es %d\n",cambio); 
printf("\n\t%d billetes de $200", cambio/200); 
cambio = cambio%200; 
printf("\n\t%d billetes de $100", cambio/100); 
cambio = cambio%100; 
printf("\n\t%d billetes de $50", cambio/50); 
cambio = cambio%50; 
printf("\n\t%d billetes de $20", cambio/20); 
cambio = cambio%20; 
printf("\n\t%d monedas de $10", cambio/10); 
cambio = cambio%10; 
printf("\n\t%d monedas de $5", cambio/5); 
cambio = cambio%5; 
printf("\n\t%d monedas de $2", cambio/2); 
cambio = cambio%2; 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 40 
printf("\n\t%d monedas de $1", cambio); 
 
printf("\n\nAgradecemos su preferencia, disfrute su 
película\n\n"); 
system("pause");/*hará una pausa antes de terminar la ejecución*/ 
}/*fin main*/ 
Programa: ventaBoletos.c 
 
El resultado de la ejecución del programa utilizando los mismos datos de entrada 
de la prueba de escritorio es: 
 
 Ejecución del programa: ventaBoletos.c 
 
 
2.7. Estructuras de control 
 
Cualquier algoritmo puede ser escrito utilizando tres tipos de instrucciones,conocidas como estructuras de control (Kerningham, y Ritchi, 1986), las cuales 
son: 
o Secuenciales (cuando se ejecutan una tras otra) 
o Selectivas (cuando se ejecutan dependiendo de una condición) 
o Repetitivas (que se ejecutan varias veces en función de una condición) 
 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 41 
Su objetivo es controlar el flujo de ejecución de un programa, es decir, el 
orden en que se ejecutan las instrucciones. Considerando que ya has 
diseñado algoritmos secuenciales y los codificaste en lenguaje C para obtener 
el programa deseado que diera solución al problema en cuestión, podemos 
decir que solamente te falta saber cómo funcionan y cómo se codifican en 
lenguaje C las otras dos estructuras para poder diseñar algoritmos 
estructurados. Así que éste será justamente el tema de esta sección, donde 
estudiarás con más detalle los tipos y funcionamiento de las estructuras 
selectivas y repetitivas. 
 
Para su mejor comprensión, esta sección está dividida en dos partes: 
En la primera revisarás algunos problemas donde la solución implica tener 
que elegir el camino que se debe seguir para llegar al resultado deseado, esto 
se soluciona utilizando estructuras selectivas, por lo cual analizarás a mayor 
profundidad el significado (semántica) de cada estructura y verás la forma de 
codificarla (sintaxis) en lenguaje C. 
 
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. 
 
2.7.1. Estructuras selectivas 
 
Para diseñar programas capaces de tomar decisiones se requiere de las 
estructuras de control selectivas, también llamadas condicionales. Éstas 
llevan a cabo su función (controlar el flujo del programa) mediante una 
condición que se representa utilizando expresiones booleanas, de tal manera 
que cuando la condición se cumple (es verdadera) se ejecuta un conjunto de 
instrucciones definidas para este caso y, dependiendo del tipo de estructura, 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 42 
es posible que se ejecute otro conjunto de instrucciones distinto para el caso 
contrario (cuando la condición es falsa); e incluso, es posible definir diferentes 
conjuntos de instrucciones para valores distintos que pudiera tomar una 
variable. Es así que dependiendo de su estructura se han definido tres tipos: 
simples, dobles y múltiples. 
 
Para el estudio de cada estructura selectiva, a continuación, se dedican tres 
sub-secciones, una para cada una, en las cuales entenderás cómo funcionan 
y la forman en que se codifican en lenguaje C. 
 
 
Estructura selectiva simple (if) 
La estructura de decisión simple, como su nombre lo indica, permite decidir 
entre ejecutar o no un bloque de acciones; en pseudocódigo se propuso la 
palabra reservada Si para su representación y en lenguaje C esta estructura 
se codifica mediante la sentencia de control if, tal como se muestra en la 
siguiente tabla. 
 
Pseudocódigo Diagrama de Flujo Código en C 
Si <condición> 
entonces 
<instrucciones> 
Fin Si 
 
 
if(<condición>) 
 
<instrucciones> 
 
Representaciones de la estructura condicional simple. 
 
La <condición> puede ser cualquier expresión booleana y las <instrucciones>, 
llamadas cuerpo del Si (if), bien puede ser una sola instrucción o un bloque 
de instrucciones en cuyo caso van entre llaves {}. 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 43 
La manera en la que se ejecuta una instrucción Si (if) es la siguiente: se evalúa 
la condición que aparece entre paréntesis y si es verdadera (tiene un valor 
diferente de cero) entonces se ejecutan las instrucciones del cuerpo del Si (if), 
en caso de no serlo no se ejecuta y continúa el flujo de ejecución. 
 
NOTA: En lenguaje C, cuando el cuerpo de una estructura tiene más de una 
instrucción éstas deben ir encerradas entre llaves. 
 
Para ilustrar las representaciones y el funcionamiento de la estructura 
selectiva simple se presenta el siguiente problema, con el algoritmo en 
pseudocódigo, el diagrama de flujo y el programa en lenguaje C. 
 
Problema de sentencias de estructuras selectivas simples: 
Se requiere un programa que lea un valor entre 0 y 360 y determine el tipo 
de ángulo, considerando que: 
• Ángulo agudo: Mayor a cero y menor de 90 grados 
• Ángulo recto: Es igual a 90 grados 
• Ángulo obtuso: Es mayor que 90 pero menor a 180 grados 
• Ángulo llano: Es igual a 180 grados 
• Ángulo cóncavo: Es mayor a 180 pero menor a 360 grados 
 
El análisis del problema se resume en la siguiente tabla. 
Análisis del problema 
Datos de entada: 
ángulo 
 
Salida: 
Mensaje 1: “Agudo” 
Mensaje 2: “Recto” 
Mensaje 3: 
“Obtuso” 
Mensaje 4: “Llano” 
Mensaje 5: 
“Cóncavo” 
Método: 
Realizar comparaciones 
utilizando la estructura 
de selección simple, con 
el fin de identificar el 
tipo de ángulo, 
dependiendo de sus 
grados. 
Análisis del problema 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 44 
 
Lo primero que se requiere es leer el valor del ángulo, posteriormente, 
verificar de qué tipo es para imprimir el mensaje indicado. A continuación, se 
muestra el algoritmo tanto en pseudocódigo como en diagrama de flujo: 
Inicio 
 Imprimir "Ingrese la medida del ángulo (grados): " 
 Leer ángulo 
 Si angulo≤0 OR angulo≤360 entonces 
Imprimir “No tiene clasificación" 
 Fin_Si 
 
 Si angulo>0 AND angulo<90 entonces 
Imprimir "El ángulo es agudo" 
 Fin_Si 
 
 Si angulo=90 entonces 
 Imprimir "El ángulo es recto" 
 Fin_Si 
 
 Si angulo>90 AND angulo<180 entonces 
Imprimir “El ángulo es obtuso" 
 Fin_Si 
 
 Si angulo =180 entonces 
 Imprimir "El ángulo es llano" 
 Fin_Si 
 
 Si angulo>180 AND angulo<360 entonces 
 Imprimir “El ángulo es cóncavo" 
 Fin_Si 
Fin 
Ejemplo de aplicación de estructura selectiva simple: Tipo de ángulo – pseudocódigo. 
 
Observa que, para hacer más legible el algoritmo en pseudocódigo, se han 
dejado sangrías para indicar qué instrucciones forman el cuerpo de cada una 
de las estructuras Si y se han encerrado con un rectángulo, esto se adoptará 
para cualquier bloque de instrucciones que corresponda al cuerpo de una 
estructura. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 45 
 
 
 
Ejemplo de aplicación de estructura selectiva simple: Tipo de ángulo – diagrama de flujo. 
 
Para reafirmar el funcionamiento de la estructura condicional simple y 
verificar que el algoritmo propuesto sea correcto, en la siguiente tabla se 
muestra su ejecución paso a paso, tomando como datos de entrada 120 
grados. 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 46 
 
Ejemplo de aplicación de estructura selectiva simple: Prueba de escritorio del algoritmo. 
 
Al ejecutar paso a paso el algoritmo la única condición que satisface el estado 
de la memoria es la que sombreamos (angulo>90 AND angulo<180), por lo 
tanto, la única instrucción que se toma en cuenta es la del cuerpo del Si 
correspondiente. 
 
El último paso es la codificación. Observa que el cuerpo de cada una de las 
estructuras consta de una instrucción por lo tanto no es necesario encerrarla 
entre llaves {}. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 47 
/* 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 () 
{ /*Inicio de la función Principal*/ 
 
/*Declaración de variables */ 
intangulo; 
 
 /*Mensaje de bienvenida*/ 
printf ("\nEste programadetermina 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 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 48 
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. 
 
Ejemplo de aplicación de estructura selectiva simple: Ejecución del programa tipoAngulo.c 
 
 
Estructura selectiva doble (if-else) 
Las estructuras selectivas dobles nos permiten elegir alguna de dos posibles 
acciones a realizar dependiendo de la condición. En pseudocódigo se 
propone usar las palabras reservadas Si-Sino y en C se codifican mediante la 
sentencia if-else, tal como se muestra en la siguiente tabla. 
 
Pseudocódigo Diagrama de Flujo Lenguaje C 
Si (<condición>) 
entonces 
<instruccionesV> 
sino 
<instruccionesF> 
Fin Si-Sino 
 
 
if(<condición>) 
<instruccionesV> 
else 
<instruccionesF> 
 
Representaciones de la estructura condicional doble. 
 
Al igual que en la estructura selectiva simple, la <condición> representa una 
expresión booleana y, las <instruccionesV> y <instruccionesF> puede ser una 
o varias, a las primeras se les llama cuerpo del Si (if) y las segundas son el 
cuerpo del Sino (else). 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 49 
Esta estructura de control ejecuta sólo uno de los dos cuerpos de 
instrucciones: cuando la condición es verdadera se ejecutan las 
<instrucciuonesV> y en caso contrario se ejecutan las <instruccionesF>. 
 
En el desarrollo del siguiente problema se ejemplifican las representaciones 
y el funcionamiento de ésta estructura. 
 
Problema de aplicación de estructura selectiva doble: 
 
Se requiere un programa que simule el cálculo y muestre las raíces reales 
para una ecuación de segundo grado de la forma: 
 
 𝑎𝑥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𝑎𝑐 
 
De lo contrario el resultado de la raíz cuadrada sería un número imaginario. 
Para esto se propone una estructura selectiva doble para verificar que 
existan raíces reales. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 50 
 
El algoritmo en pseudocódigo es el siguiente: 
Inicio 
 Imprimir “Ingresa los coeficientes a, b y c:” 
 Leer a, b, c 
det←𝑏2 − 4𝑎𝑐 
 Si (det ≥ 0 ) entonces 
 x1←
−𝑏+√𝑑𝑒𝑡
2𝑎
 
 x2 ← 
−𝑏−√𝑑𝑒𝑡
2𝑎
 
Imprimir “Las raíces son:”, x1 , x2 
 Si no 
Imprimir “No existen raíces reales” 
Fin_Si-Sino 
Fin 
Problema de aplicación de estructura selectiva doble: Algoritmo pseudocódigo. Ecuación de segundo 
grado. 
 
 
Observa que en el algoritmo se utiliza la variable auxiliar det, la razón es 
porque el cálculo del determinante (𝑏2 − 4𝑎𝑐) se emplea en más de un lugar 
del algoritmo, por lo tanto, se recomienda guardar este resultado para no 
volverlo a calcular. 
 
Ahora, la representación del mismo algoritmo en diagrama de flujo se 
muestra a continuación. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 51 
 
Problema de aplicación de estructura selectiva doble: diagrama de flujo Ecuación de segundo 
grado. 
 
Para validar el algoritmo, veamos su ejecución paso a paso con el polinomio 
𝑥2 + 5𝑥 + 4 = 0. 
 
Problema de aplicación de estructura selectiva doble: Prueba de escritorio del algoritmo. 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 52 
 
Para la codificación en lenguaje C se debe notar que el cuerpo del Si (if) tiene 
un bloque de tres instrucciones, por lo que deberán ir encerradas entre llaves 
{}, en cambio el cuerpo del Sino (else) sólo tiene una instrucción por lo que no 
son necesarias. 
 
 
/* 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; 
 
/* Verificamos que la ecuación tenga raíces reales */ 
if (det>= 0) 
 { 
 x1=(-b + sqrt(det))/2*a; 
 x2=(-b - sqrt(det))/2*a; 
 printf ("\n Las raíces son: %.2lf, %.2lf",x1, x2); 
 } 
else 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 53 
 printf ("\n No existen raíces reales."); 
 printf ("\n"); 
 system ("pause"); 
} 
Problema de aplicación de estructura selectiva doble: codificación ecuacion.c 
 
La ejecución del programa con los mismos datos de entrada de la prueba de 
escritorio es la siguiente. 
 
Problema de aplicación de estructura selectiva doble: Ejecución del programa ecuacion.c 
 
 
Estructura selectiva múltiple (switch-case) 
 
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). 
 
Para la estructura condicional múltiple se proponen las palabras clave 
Seleccionar-caso en pseudocódigo, misma que se implementa en lenguaje C 
utilizando las palabras reservadas switch-case. Esta secuencia se utiliza 
cuando existen múltiples posibilidades para la evaluación de una expresión 
matemática (generalmente una variable), pues de acuerdo al valor que tome 
la expresión será el conjunto de instrucciones que se ejecute. 
 
 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 54 
 
Pseudocódigo Lenguaje 
Casos para<expresión> 
caso<valor1>: 
<instruccionesCaso1> 
caso<valor2>: 
<instruccionesCaso2> 
 … 
otros casos: 
<instruccionesOtros> 
Fin_Casos 
 
 
 
 
switch (<expresión>) 
{ 
case<valor1>: 
 <instrucciones1>; 
break; 
 case<valor2>: 
 <instrucciones2>; 
break; 
default: 
<instruccionesOtras> 
} 
Diagrama de Flujo 
 
 Representaciones de la estructura condicional múltiple. 
 
En este caso la <expresión> no es booleana sino aritmética y de tipo entero, 
así cada caso corresponde a un valor que puede resultar de su evaluación. De 
esta forma, el flujo de control que sigue la ejecución de una instrucción 
Seleccionar-casos (switch-case) es el siguiente: se evalúa la <expresión> y si el 
valor correspondeal valor de un caso, es decir a un <valori>6, se ejecuta el 
bloque de <instruccionesi> hasta encontrar el final de la instrucción, que en el 
caso de C está representado por la palabra reservada break, terminando ahí 
la ejecución de la instrucción. Cuando el valor no corresponde a ningún caso 
 
6 El valor i indica una serie de valores (números enteros) desde 1 a n valores. 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 55 
se ejecuta el bloque de instrucciones correspondiente a otros casos (default). 
El conjunto de todos los casos, incluyendo el default, conforman el cuerpo de 
la estructura Seleccionar-casos (switch-case). 
 
Problema de estructura selectiva múltiple: Se requiere un programa que 
dada una calificación numérica despliegue un mensaje, de acuerdo con la 
siguiente información: 
0-6: Reprobado 
7: Suficiente, Aprobado 
8: Bien, Aprobado 
9: Notable, Aprobado 
10: Sobresaliente, Aprobado 
 
En este caso es conveniente utilizar una estructura selectiva múltiple, en 
donde la expresión que se evalúe sea la calificación del estudiante y se defina 
un caso por cada una de las calificaciones posibles. Es claro, que la entrada 
únicamente es la calificación y la salida es el mensaje correspondiente. De lo 
anterior el algoritmo en pseudocódigo y diagrama de flujo quedaría de la 
siguiente forma. 
Inicio 
Imprimir “Inserte una calificación: " 
Leer nota 
Seleccionar (nota) 
 caso 0: caso 1: caso2: caso 3: caso 4: caso 5: caso 6: 
Imprimir “Reprobado" 
caso 7: Imprimir "Suficiente, Aprobado" 
 caso 8: Imprimir "Bien, Aprobado" 
 caso 9: Imprimir “Notable, Aprobado” 
 caso 10: Imprimir “Sobresaliente, Aprobado” 
 otros casos: Imprimir "Esa nota es incorrecta" 
Fin_Casos 
Fin 
Problema de estructura selectiva múltiple: Pseudocódigo de un programa que determina un valor 
cualitativo a partir de un valor numérico cuantitativo. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 56 
 
Problema de estructura selectiva múltiple: Diagrama de flujo de un programa que determina un valor 
cualitativo a partir de un valor numérico cuantitativo. 
 
Observa que tanto en el diagrama de flujo como en el algoritmo, hay siete 
casos (0 ≤ 𝑛𝑜𝑡𝑎 ≤ 6) en los que la instrucción a ejecutar es la misma, por lo que 
se agrupan, más no se puede poner una condición que los contenga, como 
se haría en las estructuras vistas anteriormente, así que en el pseudocódigo 
se especifica cada valor antecedido por la palabra caso pero sólo se escribe 
una vez la instrucción y, de manera similar, se listan todos los valores. Para 
aclarar el funcionamiento de esta estructura y verificar si el algoritmo 
funciona adecuadamente, en la siguiente tabla se muestra una prueba de 
escritorio cuando la nota es igual a 8. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 57 
 
Problema de estructura selectiva múltiple: Prueba de escritorio de un programa que determina un 
valor cualitativo a partir del valor numérico 8. 
 
Es importante señalar que, a diferencia de las estructuras anteriores, el 
cuerpo de una estructura selectiva múltiple siempre debe ir encerrado entre 
llaves {} cuando se codifica en C, más no así las instrucciones que se definen 
para cada caso, ya que éstas se acotan por las palabras reservadas case y 
break, por tal motivo no debes olvidar escribir el break al final de cada caso 
de lo contrario también se ejecutarán las instrucciones de los casos que 
aparezcan después. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 58 
/* Programa: calificacion.c 
 * Descripción: Dada una calificación con número despliega un 
mensaje 
 * 0,1,2,3,4,5,6 - Reprobado 
 * 7 - Suficiente, Aprobado 
 * 8 - Bien, Aprobado 
 * 9 - Notable, Aprobado 
 * 10 - Sobresaliente, Aprobado*/ 
 
#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",&nota); 
 /*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. 
 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 59 
En la siguiente figura se muestra la ejecución de este programa con el valor 
de entrada igual a 8. 
 
Problema de estructura selectiva múltiple: Ejecución de un programa que determina un valor 
cualitativo a partir de un valor numérico 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. 
 
2.7.2. Estructuras repetitivas 
 
En la mayor parte del diseño o implementación de las soluciones que se 
plantea a problemas específicos nos encontramos con instrucciones que 
deben ejecutarse un número determinado de veces, si hacemos un análisis 
más profundo de estas situaciones, en la mayoría de las ocasiones nos 
encontramos que las instrucciones son las mismas, pero que los datos varían, 
esto se hace posible utilizando las estructuras repetitivas, generalmente 
llamadas ciclos (Cairó, 2006). 
 
Existen varias estructuras de repetición implementadas por los diferentes 
lenguajes de programación, todas con la misma idea: repetir un conjunto de 
instrucciones, llamadas cuerpo del ciclo, dependiendo de condición. En la 
Unidad 2. Introducción al lenguaje C 
 
UNADM | DCEIT | FPR 60 
mayoría de los ciclos, el cuerpo se repite siempre y cuando la condición se 
cumpla, sin embargo, también existe una estructura repetitiva que se repite 
en tanto que no se cumple la condición. En esta sección sólo nos enfocaremos 
en las primeras que son las que están definidas en el lenguaje C y en la 
mayoría de los lenguajes estructurados y orientados a objetos actuales. Cabe 
mencionar que a cada una de las veces que se repite el ciclo se le conoce 
como iteración. 
 
Cuando se utilizan ciclos dentro de un programa, te puedes enfrentar a dos 
posibles situaciones: 
• Que conozcas desde el diseño cuántas veces deben repetirse las 
instrucciones (repetición definida), 
• Que el número de veces que se deban repetir las instrucciones 
dependa de un valor que se conoce hasta el momento de la ejecución 
del ciclo (repetición indefinida). 
 
En el primer caso se necesitará una variable que funja como un contador, en 
la cual se registre el número de iteraciones que se vayan ejecutando. En 
cambio, en las repeticiones indefinidas generalmente se controlan mediante 
interruptores o banderas, o bien, con valores centinela. 
 
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: