FPR U2 Contenido

Ciencias Exactas Ingeniería y Tecnología
Programa de la asignatura:
Fundamentos de programación
Unidad 2. Introducción al lenguaje C
Universidad Abierta y a Distancia de México

Índice
Unidad 2: introducción al lenguaje c........................... 3
Presentación de la unidad...................................... 3
Competencia específica......................................... 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...................... 10
2.2. Tipos de datos........................................... 12
2.3. Variables y constantes................................... 14
2.3.1. Identificadores........................................ 14
2.3.2. Declaración e inicialización de variables.............. 16
2.3.3. Tipos de constantes.................................... 18
2.3.4. Declaración de constantes.............................. 20
2.4. Expresiones matemáticas.................................. 21
2.4.1. Tipos de operadores.................................... 23
2.4.2. Evaluación de expresiones.............................. 25
2.5. Bibliotecas y funciones.................................. 28
2.5.1. Funciones matemáticas.................................. 29
2.5.2. Funciones de entrada y salida.......................... 30
2.6. Codificación de algoritmos............................... 33
2.7. Estructuras de control................................... 41
2.7.1. Estructuras selectivas................................. 42
2.7.2. Estructuras repetitivas................................ 60
2.7.3. Estructuras anidadas................................... 81
Cierre de la unidad........................................... 85
Fuentes de consulta........................................... 86
UNADM | DCEIT | DS | FPR 2

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.

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.

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
operaciones que 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 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 El texto que se encuentra entre los
preprocesador*/ 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
o: output
std: estándar
i: input
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 Es un comentario que describe la
Principal */ función principal del programa.
main( ) Definición de función Principal del
{ programa.
printf(“Hola mundo… \n”); 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 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”);
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
1 En este punto es importante destacar que el lenguaje C distingue entre mayúsculas y minúsculas.

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.
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
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 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.
En general, los tipos de datos que existen, independientemente

de un lenguaje de programación, se pueden clasificar de la
siguiente forma:
Enteros
 Numéricos
Decimales
Simples
 Lógicos (verdadero o falso)
 Alfanuméricos (caracteres)
Unidimensionales
 Arreglos
Estructurados 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
2 Recuerda que un bit se definió como la unidad mínima de información, esto es, 1 ó 0.

Su tamaño equivale a ´a´,

ocho bits, capaz de ´C´, ´3´
char contener un carácter
del conjunto de
caracteres ASCII.
Un entero,
normalmente ocupa 1024,
mínimo 16 bits, pero -258
int
su tamaño es según la
máquina en que se
ejecute.
Número de punto 10.5,
Float flotante de -11.6
precisión normal.
Punto flotante de
Double 0.00045,
doble precisión
-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 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 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í.
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*/
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.
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.

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…
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.
‘\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:
#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.
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.
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 */
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

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 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.
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
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
𝐹 = 𝐶 + 32
5
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
C F
F= (9.0/5.0)*C +32;
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
C F
F= 86;
30 86
Observa que el único operador que cambia el estado de una

variable es el de asignación “=”.
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
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
“<>”
Si deseas más información se te recomienda consultar (Joyanes & Zohanero, 2005).

3

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.h declara 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.
Función Descripción Argumento Resultado Ejemplo
sqrt(x) Raízcuadrada Flotante flotante sqrt(900) =
exp(x) Function exponencial Flotante flotante exp(2.0)=
90
fabds(x) Valor absoluto entero o entero o fabs(-5)
2.718282 = 5
log(x) Logaritmoneperiano de x entero o
flotante flotante log(0.5) = -
Log10(x) logaritmo decimal de x entero
flotateo flotante Log10(0.5)
0.693 =
floor(x) Redondeohaciaabajo Flotante
flotante entero floor(6.5)=6
-0.301
ceil(x) Redondeohaciaarriba Flotante entero ceil(6.5)=7
4 En (Kernighan & Ritchie, 1991) puedes consultar las funciones que están definidas en cada una de las bibliotecas estándar.

sen(x) seno de x entero o flotante sen(0.5) = 0

pow(x,y) Devuelve la potencia de entero
real o flotante pow(5,2) = 25
cos(x) x elevada
coseno a la y
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.
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)
Insertar un entero tipo
%i
(int)
Insertar un entero tipo
%ld
(long)
Insertar un número
%f
flotante tipo (float)
Insertar un número de
%lf
tipo (double)
Insertar un caracter
%c
(char)
Insertar una cadena(char
%s
[ ])
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.
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.
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.

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 resuelve el problema.
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.

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
es”, cambio/100
es”, cambio/50
Imprimir “El número de monedas de 10 pesos es”,
cambio/10
cambio/5
cambio/2
Imprimir “El número de monedas de 1 peso es”,
cambio
Fin
Ejemplo del algoritmo: ventaBoletos (pseudocódigo).

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.

Dato de Estado de la memoria Dato de

Instrucción Operaciones
entrada (variables y constantes) salida
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 =
PRECIO nBoletos total pago cambio
nBoletos*PRECIO - 5*45 -
45 5 225 - -
=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 de billetes
billetes de - 275/200 = 1
45 5 225 500 275 de $200 es
$200 es”,
1
cambio/200
cambio = cambio cambio = PRECIO nBoletos total pago Cambio
- -
módulo 200 275 mod 200 45 5 225 500 75
UNADM | DCEIT | FPR 37

=75
Imprimir “El
El número
número de
PRECIO nBoletos total pago Cambio de billetes
billetes de - 75/100 = 0
45 5 225 500 75 de $100 es
$100 es”,
0
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 mod 50 -
módulo 50 45 5 225 500 25
=25
Imprimir “El
El número
- 25/50= 0 de billetes
billetes de $20 45 5 225 500 25
de $50 es 0
es”, cambio/20
cambio =
- 25 mod 20 -
módulo 20 45 5 225 500 5
=5
Imprimir “El
El número
- 5/10= 0 de monedas
monedas de $10 45 5 225 500 25
de $10 es 0
es”, cambio/10
cambio =
- 5 mod 10 -
módulo 10 45 5 225 500 5
=5
Imprimir “El El número
- 5/5= 1 PRECIO nBoletos total pago Cambio
número de de monedas

monedas de $5 45 5 225 500 5 de $5 es 1

es”, cambio/5
cambio =
- 5 mod 5 -
módulo 5 45 5 225 500 0
=0
Imprimir “El
El número
- 0/2= 0 de monedas
monedas de $2 45 5 225 500 0
de $2 es 0
es”, cambio/2
cambio =
- 0 mod 2 -
módulo 2 45 5 225 500 0
=0
Imprimir “El
El número
- - 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);
/*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;
cambio = cambio%100;
cambio = cambio%50;
cambio = cambio%20;
printf("\n\t%d monedas de $10", cambio/10);
cambio = cambio%10;
cambio = cambio%5;
cambio = cambio%2;

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)
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, 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
if(<condición>)
Si <condición>
entonces
<instrucciones>
<instrucciones>
Fin Si
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 {}.

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
Salida: Método:
Mensaje 1: Realizar
“Agudo” comparaciones
Datos de entada: Mensaje 2: utilizando la
ángulo “Recto” estructura de
Mensaje 3: selección simple, con
“Obtuso” el fin de
Mensaje 4: identificar el tipo
“Llano” de ángulo,

Mensaje 5: dependiendo de sus

“Cóncavo” grados.
Análisis del problema
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

Imprimir “El ángulo es obtuso"
Fin_Si
Si angulo =180 entonces

Imprimir "El ángulo es llano"
Fin_Si

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.
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.
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 {}.
/* 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;
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");
printf ("\n El ángulo es obtuso");
if (angulo ==180)
printf ("\n El ángulo es llano");

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.
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>)
if(<condición>)
entonces
<instruccionesV>
<instruccionesV>
else
sino
<instruccionesF>
<instruccionesF>
Fin Si-Sino
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).
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.

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.

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.

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*/
main ( )
{
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
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.

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
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 corresponde al 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 se
6 El valor i indica una serie de valores (números enteros) desde 1 a n valores.

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.

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.

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.

/* 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.

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 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: contadores, acumuladores e
interruptores.

Un contador es una variable comúnmente de tipo entero destinada
a almacenar un valor que se irá incrementando o decrementando
en una cantidad constante. Se suelen utilizar mucho en procesos
repetitivos definidos, para contabilizar el número de veces que
se repite un conjunto de acciones o eventos, es decir en los
cuerpos de las instrucciones repetitivas. Sobre una variable
contadora se realizan dos operaciones básicas: inicialización e
incremento o decremento, según sea el caso. Todo contador se
debe inicializar con un valor inicial (0, 1...)
contador = Valor_Inicial
Cada vez que aparezca el evento a contar se ha de incrementar o

decrementar en una cantidad fija (I, D respectivamente) el
valor del contador.
contador = contador+ I;
contador = contador- D;
Los contadores más utilizados tienen incrementos o decrementos

de uno en uno, es por ello que la simplificación de dichas
expresiones es:
Expresión Expresión
Simplificada en
lenguaje C
contador=contador contador++
+1;
contador=contador contador--
-1;
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.

Un acumulador es una variable cuyo objetivo es almacenar
cantidades sucesivas que se obtienen al realizar la misma
operación. El uso más habitual de un acumulador es obtener
sumas y productos. Al igual que con los contadores, para poder
utilizar un acumulador hay que realizar sobre ellos dos
operaciones básicas: inicialización e incremento.
En el caso de obtener sumas el acumulador se inicializa en cero

y en el caso de los productos en uno, para no afectar el
resultado.
SumaTotal=0;
ProductoFinal=1;
Una vez obtenido y almacenado en una variable la cantidad a

acumular la añadimos a la variable acumulador:
Variable Acumulador
Cantidad a Acumular
SumaTotal = SumaTotal +
cantidad;
ProductoFinal = ProductoFinal *
cantidad;
En resumen, los contadores permiten llevar la cuenta del número

de iteraciones que se realizan en un ciclo (definido o
indefinido), y en el caso específico de ciclos definidos son el
medio por el cual se controla el fin del ciclo. Por otro lado,
los acumuladores nos permiten guardar resultados parciales de
operaciones que se realizan como parte del cuerpo de un ciclo
(puede ser definido o indefinido). En este punto, es importante
señalar que en lenguaje C hay tres diferentes estructuras
repetitivas: while (Mientras-hacer), for (Desde-mientras) y do-
while (Hacer-mientras), con todas ellas es posible modelar
ciclos definidos o indefinidos, pues las tres son equivalentes,

es decir, cualquiera de ellas se puede expresar en términos de
las otras. En los siguientes subtemas estudiarás a profundidad
cada una de ellas y verás su equivalencia.
Estructura repetitiva Mientras (while)

La estructura repetitiva Mientras, codificada en lenguaje C con
la palabra reservada while, controla las repeticiones a partir
de una condición que se evalúa al inicio del ciclo, de esta
manera en cada iteración primero se evaluará la condición y
mientras resulte verdadera se repetirá el ciclo. En la
siguiente tabla se muestran las representaciones del ciclo
Mientras (while).
Mientras while
<condición>hacer (<condición>)
Condición V F
<instrucciones> <instrucciones>;
Fin mientras
instrucciones
Representaciones de la estructura repetitiva Mientras (while).
La manera en la que se ejecuta una instrucción Mientras (while)

es la siguiente: las <instrucciones> del cuerpo del ciclo se
ejecutan mientras la <condición> es verdadera, cuando esto no
se cumple se termina el ciclo; de esta forma, si la primera vez
que se evalúa la condición esta es falsa, el cuerpo del ciclo
no se ejecuta ni una sola vez.
Para ejemplificar cómo se construye un ciclo indefinido

utilizando un valor centinela, se propone el siguiente
problema.

Ejemplo de estructura repetitiva Mientras (while):

Se requiere un programa que calcule el promedio de temperaturas
que registra una ciudad, las temperaturas se introducirán en
grados Farenheit °F y no se conoce de antemano el número de
temperaturas que el usuario introducirá.
Para resolver el problema planteado se podría pedir el número

de temperaturas que se desean registrar para calcular el
promedio, pero esto equivale a una estructura de repetición
definida, si decidiéramos dejar abierto este dato hasta el
momento de la ejecución del programa, tendríamos que construir
una condición que haga que el ciclo se repita mientras que el
usuario desea ingresar temperaturas. Pero ¿cómo se puede
resolver esto? En casos como este se propone utilizar un valor
centinela que indique el fin de la captura de datos. Claramente
el valor centinela debe ser seleccionado de tal forma que no se
confunda con algún valor de entrada aceptable, por ejemplo
podríamos considerar que dado que existe un límite mínimo de
temperaturas en grados Farenheit, a saber -460°F, el valor
centinela sería cualquier número inferior a éste, es claro que
no existe una temperatura más baja, sin embargo el límite
máximo es difícil de definir ya que en forma experimental se
obtienen en los laboratorios temperaturas de miles de grados,
mientras que en una explosión atómica se alcanzan temperaturas
de millones de grados. Se supone que la temperatura en el Sol
alcanza los mil millones de grados Pérez, 1992, p. 325.
Para calcular el promedio, debemos realizar la suma de todas

las temperaturas (𝑡𝑒𝑚𝑝𝐹1 + 𝑡𝑒𝑚𝑝𝐹2 + … , + 𝑡𝑒𝑚𝑝𝐹𝑛 ) y dividirlas entre
el número total de temperaturas que se hayan leído, digamos 𝑛.
Lo anterior se expresa con la siguiente fórmula.

∑ 𝑡𝑒𝑚𝑝𝐹𝑖
𝑝𝑟𝑜𝑚𝑇 ←
𝑛
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.
La representación del algoritmo en diagrama de flujo se muestra

en la siguiente figura:

Ejemplo de estructura repetitiva Mientras (while): diagrama de flujo para calcular el

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;
/* Lectura de la primera temperatura */

printf ("Programa que calcula el promedio de temperaturas en
grados Fahrenheit\n\n\n");
printf ("\n Ingrese la primera temperatura registrada:");
scanf ("%f",&tempF);
/* Codificación del ciclo */

while (tempF>= centinela)
{
/* Se registra la temperatura que se leyó */
c = c + 1;
/* Se acumulala temperatura en la suma */
sumaF=sumaF+tempF;
/* Se lee la siguiente temperatura */
printf ("\n\nIngrese la siguiente temperatura (si desea
terminar ingrese un número menor a %d): ", centinela);
scanf ("%f",&tempF);
}
/* Promedio de Temperaturas Fahrenheit */

promF=sumaF/c;
printf ("\nPromedio de temperaturas =%.2f\n", promF);

system ("pause");
}
Ejemplo de estructura repetitiva Mientras (while): codificación para calcular el
Por último, en la siguiente figura se muestra la ejecución del

programa con los mismos datos que se utilizaron en la prueba de
escritorio.
Ejemplo de estructura repetitiva Mientras (while): ejecución del programa para

calcular el Promedio de temperaturas.
Estructura para-mientras (for)
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).
En este caso, primero se realiza la <inicialización> que

corresponde a la asignación de un valor inicial de una variable
(el contador), posteriormente se evalúa la <condición> si es
verdadera se ejecutan las <instrucciones> del cuerpo del ciclo
y, posteriormente, se incrementa o decrementa el contador,
según sea el caso, para después volver a repetir el ciclo,
excepto por la <inicialización> que sólo se ejecuta una vez.
Es importante señalar que si te centras en la representación en

diagrama de flujo de este ciclo podrás darte cuenta que se
parece al diagrama del ciclo while, salvo por la inicialización
y el incremento (o decremento); de hecho, si partes del
diagrama de flujo para la codificación puedes utilizar un
while. De igual manera, un ciclo while se puede representar con
un ciclo for cuya <inicialización> e <incremento/decremento>

son vacíos, sólo se define la condición. Con lo anterior se
muestra la equivalencia de las dos estructuras.
Para ejemplificar las representaciones, codificación y

funcionamiento de esta estructura se presenta el siguiente
problema desarrollado.
Problema de aplicación de una estructura para-mientras (for):

Se requiere un programa que calcule el total de la nómina de
los trabajadores de una empresa.
El problema es similar al que se presentó en la sección

anterior, se debe leer el pago de cada trabajador y realizar la
suma de cada uno de éstos, para lo cual se puede utilizar un
acumulador. La diferencia es que en este caso no se utilizará
un valor centinela para terminar la lectura de los pagos, pues
se preguntará al usuario al inicio del programa cuántos
trabajadores hay, así el número de iteraciones quedará
determinado antes de iniciar el ciclo. De lo anterior tenemos
que si el número de empleados es n entonces el ciclo debe
repetirse n-veces, para lo cual se utilizará un contador c que
debe tomar los valores 1,2,…, n, así que el ciclo debe
repetirse siempre que c ≤ n. En cuanto a la suma de los pagos,
se utilizará un acumulador, al cual llamaremos nom, que se
inicializará en cero dado que se trata de una suma. Observa la
solución del problema.
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.
En la siguiente tabla se muestra la ejecución paso a paso del

ciclo suponiendo que se quiere calcular la nómina de tres

empleados, que ya se ha leído el dato y que fue registrado en
la variable n, la cual no cambia su valor a lo largo de la
ejecución del ciclo.
Problema de aplicación de una estructura para-mientras (for): prueba de escritorio

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;
/* Lectura del número de empleados */

printf ("Cálculo de la Nómina\n\n ");
printf ("Ingrese el total de empleados: ");
scanf ("%d",&n);
nom=0;
/*Ciclo definido de 1 hasta el número de empleados ingresados*/
for (c=1;c<=n;c=c+1)
{
printf ("\nIngresa el salario del trabajador %d: ", c);
scanf ("%f",&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
En la siguiente figura se muestra la ejecución del programa con

los mismos datos de entrada que se utilizaron en la prueba de
escritorio.
Problema de aplicación de una estructura para-mientras (for): ejecución del programa

Nomina.c.

Estructura hacer-mientras (do-while)

A diferencia de las estructuras repetitivas anteriores en las
cuales las condiciones se evalúan al principio del ciclo
ocasionando que las instrucciones que se repiten se ejecuten de
0 hasta N veces, en la estructura Hacer-mientras (do-while) la
evaluación se lleva acabo al final, esto implica que el
conjunto de instrucciones que se repite se ejecuta al menos una
vez.
Hacer do
<instrucciones> <instrucciones>;
while(<condición>);
Mientras
<condición>Fin
Representaciones de la estructura repetitiva Hacer-mientras (do-while)
Observa que, en el código en C, la única estructura de control

de todas las que hemos visto que tiene punto y coma después de
la expresión o condición es el do-while.
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.
Problema de estructura hacer-mientras (do-while):

Se requiere un programa que imprima un menú con las siguientes
opciones, el cual se repita en tanto no se elige la opción d
(Salir).
a. Calcular la fuerza

b. Calcular la aceleración
c. Calcular la masa
d. Salir
Además, dependiendo de la opción que elija el usuario se deberá

realizar la tarea indicada utilizando la segunda ley de Newton
que dicta: “La aceleración que un cuerpo adquiere es
directamente proporcional a la resultante de las fuerzas que
actúan en él, y tiene la misma dirección en el sentido que en
dicha resultante” (Castro, 2010, p. 27)
𝑓𝑢𝑒𝑟𝑧𝑎 = 𝑚𝑎𝑠𝑎 ∗ 𝑎𝑐𝑒𝑙𝑒𝑟𝑎𝑐𝑖ó𝑛
En este caso, para resolver la parte del menú se utilizará un

switch-case, en el que cada opción del menú corresponda a un
caso, así las instrucciones que lo forman deben ser: la lectura
de los datos correspondientes y la operación apropiada (que se
define despejando la variable en cuestión de la fórmula dada).
Para que el menú se repita se plantea un ciclo while que se
ejecute mientras la opción sea distinta de 4 (Salir). De esta
forma el algoritmo se presenta a continuación en sus dos
representaciones.
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.
A continuación, se presenta el diagrama de flujo en el que

únicamente se ha dejado indicado en donde van las instrucciones
de los tres primeros casos, mismas que ya fueron definidas en
el pseudocódigo.

Problema de estructura hacer-mientras (do-while): diagrama de flujo Segunda ley de

Newton.
En el diagrama de flujo se puede observar claramente que el

ciclo se ejecutará mientras el usuario no elija la opción d,
que corresponde a salir, por lo que podemos concluir que el
funcionamiento del algoritmo ha sido validado. La codificación
del algoritmo se muestra a continuación.
/* 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;
/*Ciclo para repetir el menú mientras que la opción no sea salir*/

do
{/*Impresión del menú*/
system ("cls");/*Instrucción para borrar la pantalla*/
printf ("\n Realiza Cálculos trabajando la 2a. Ley de Newton");
printf ("\n ------------------------------------------------");
printf ("\n a. Fuerza. \n b. Aceleración \n c. Masa \n d. Salir");
printf ("\n Elige una opción: ");
/*Instrucción que lee una variable de tipo carácter*/

opc=getche();
/*Estructura de Selección Múltiple*/

switch (opc)
{
case 'a': printf ("\n\nIngresa la masa: ");
scanf("%f",&m);
printf ("\nIngresa la aceleración: ");
scanf("%f",&a);
f=m*a;
printf("\nLa fuerza es %.2f\n\n\t",f);
system ("pause");
break;
case 'b': printf ("\n\nIngresa la fuerza: ");
scanf("%f",&f);
printf ("\nIngresa la masa: ");
scanf("%f",&m);
a=f/m;
printf("\nLa aceleración es %.2f\n\n\t",f);
system ("pause");
break;
case 'c': printf ("\n\nIngresa la fuerza: ");
scanf("%f",&f);
printf ("\nIngresa la aceleración: ");
scanf("%f",&m);
m=f/a;
printf("\nLa masa es %.2f\n\n\t",f);
system ("pause");
break;
case 'd': printf ("\n\nAdiós\n");
system ("pause");

break;
default: printf ("\n\n Opción Inválida");
}/*Fin dela Selección Múltiple*/
}while (opc!='d');
}/*Fin*/
Problema de estructura hacer-mientras (do-while): diagrama de flujo newton.c.
En la siguiente figura se muestra la ejecución de una iteración del

ciclo, en la cual la opción elegida es la primera.
Problema de estructura hacer-mientras (do-while): ejecución del programa newton.c
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.
2.7.3. Estructuras anidadas
Las estructuras de control selectivas y repetitivas se consideran

compuestas ya que se forman a partir de otras instrucciones que son
las que se ejecutarán de acuerdo a una condición dada. Es importante
remarcar que las instrucciones que forman el cuerpo de una estructura

pueden ser también estructuras compuestas, como se demostró en la
solución del último problema visto en el tema anterior, en el cual un
switch está dentro de un while. Así que es posible anidar cualquier
tipo de estructura, sin embargo, lo más común es anidar instrucciones
if, pues se utilizan cuando se tienen varios casos, por ejemplo, si
revisamos nuevamente el problema de sentencias de estructuras
selectivas simples, donde se quiere determinar el tipo de ángulo, es
mejor solución utilizar if-anidados para resolverlo porque así no se
evalúan condiciones que, una vez que se ha definido el tipo de
ángulo, son innecesarias.
Para ilustrar lo anterior, a continuación, se muestra el

pseudocódigo y su codificación para la solución del mismo
problema.
Inicio
Imprimir "Ingrese la medida del ángulo (grados): "
Leer angulo
Si angulo≤0 OR angulo≤360 entonces

Imprimir “No tiene clasificación"
Sino Si angulo<90 entonces
Imprimir "El ángulo es agudo"
Sino Si angulo=90 entonces
Imprimir "El ángulo es recto"
Sino Si angulo<180 entonces
Imprimir “El ángulo es obtuso"
Sino Si angulo =180 entonces
Imprimir "El ángulo es llano"
Sino
Imprimir “El ángulo es cóncavo"
Fin_Si-Sino
Fin_Si-Sino
Fin_Si-Sino
Fin_Si-Sino
Fin_Si-Sino
Fin
Problema de sentencias de estructuras anidadas: pseudocódigo Tipo de ángulo.

Si realizas la prueba de escritorio con el ángulo igual a 90
grados, podrás darte cuenta que a diferencia de la primera
versión del algoritmo donde se evalúan todas las condiciones,
aquí sólo se evalúan las tres primeras, en los dos primeros Si
es falsa y por lo tanto se ejecutan las instrucciones del Sino
correspondiente, pero en el tercer Si anidado la condición es
verdadera y se imprime el tipo de ángulo, posteriormente se
acaba el anidamiento.
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>
main ()
{
intangulo;
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 if (angulo ==180)

printf ("\n El ángulo es llano");
else
printf ("\nEl ángulo es cóncavo");
printf ("\n\n\t");
system ("pause");
}
Problema de sentencias de estructuras anidadas: codificación tipoAngulo.c
La ejecución con el ángulo igual a 90 grados se muestra en la

siguiente figura.
Problema de sentencias de estructuras anidadas: Ejecución del programa tipoAngulo2.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 esta unidad se desarrollaron programas para resolver

problemas simples y medianamente complejos haciendo uso de las
funciones y de las estructuras de control de C, sin embargo,
aún nos falta aprender varias cosas que podemos implementar
para que nuestros programas resuelvan problemas cada vez más
complejos construyendo soluciones modulares que utilicen
funciones.
En cuanto a las estructuras de control, 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
instrucciones if.
En la siguiente Unidad aprenderemos a utilizar estructuras de

datos y conoceremos el concepto y la importancia de la
programación modular. Es importante que no dejes de practicar
para que puedas detectar todas las dudas o fallas que tengas a
la hora de programar con las funciones y estructuras de control
que hasta ahora conoces.
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.
Para saber más:
Existen diversas fuentes que puedes consultar para ampliar tus

conocimientos, te invito a que las explores, por ejemplo:
https://en.wikibooks.org/wiki/C_Programming

En esta página, podrás acceder a una multitud de ejemplos para

la Programación en C, a través de niveles de dificultad.
https://github.com/gorkau/Libro-Programacion-en-C
En esta página, podrás descargar diversos ejemplos alojados en

un libro especializado en el lenguaje de Programación en C.
A continuación, revisa los siguientes videos para que refuerces

tus conocimientos sobre la Programación en C++:
Programación ATS (2016) Programación en C++ [Video] Primer

programa en C++. Alojado en plataforma Youtube. Recuperado el:
24-10-2019 de: https://www.youtube.com/watch?v=ld4nzao5XAc
Danisable (2015) Aprende a programar desde cero en C/C++ [Parte

1] (Primer programa). Alojado en plataforma Youtube. Recuperado
el: 24-10-2019 de: https://www.youtube.com/watch?v=nqJPIC5V4-g
Deividcoptero Programación (2012) Curso de C++#1 Hola

Mundo/Tutorial de C++ [Video] Programación ir de C a C++.
Alojado en plataforma Youtube. Recuperado el 24-10-2019 de:
https://www.youtube.com/watch?v=tMJc8krx2n4
Fuentes de consulta
 Böhm, C., y Jacopini, G. (1966). Flow diagrams, Turing

machines, and languages only with two formation rules". En
Computational Linguistics, 9 (5), 366-371.

 Cairó, O. (2005). Metodología de la programación:

Algoritmos, diagramas de flujo y programas. México, D.F.:
Alfaomega.
 Cairó, O. (2006). Fundamentos de programación. Piensa en

C. México: Pearson Educación.
 Castro Castro, D., Et al. (2010). Manual de laboratorio de

física mecánica. Barranquilla: Ediciones UNINORTE.
 Guerrero, F. (s.f.). mailxmail.com. Recuperado de

http://www.mailxmail.com/curso-introduccion-lenguaje-c
 Joyanes, L., & Zohanero, I. (2005). Programación en C.

Metodología, algoritmos y estructuras de datos. España: Mc
Graw Hill.
 Kernighan, B., y Ritchie, D. (1991). El lenguaje de

programación C. México: Prentice-Hall Hispanoamericana.
 Levine G. (2001) Introducción a la Computación y a la

Programación Estructurada. México: Mc Graw Hill
 López, L. (2005). Programación estructurada en lenguaje C.

México: Alfaomega.
 Malva, A. Et al. (2005). Matemática discreta con

aplicaciones a las ciencias de la Programación y
Computación. Santa Fe: Universidad Nacional del Litoral.

 Muñoz Frías, J.D., y Palacios Hielscher, R. (2006).

Fundamentos de programación utilizando el lenguaje C.
Madrid: Comillas ICAI ICADE
 Reyes, A., y Cruz, D. (2009). Notas de clase: Introducción

a la programación. México: UACM.
 Villela, H. T. (20 de agosto de 2010). Manual de C.

Recuperado de http://www.fismat.umich.mx/mn1/manual/

FPR U2 Contenido

Cargado por

Copyright:

Formatos disponibles

FPR U2 Contenido

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

FPR U2 Contenido

Cargado por

Copyright:

Formatos disponibles

Ciencias Exactas Ingeniería y Tecnología

Unidad 2. Introducción al lenguaje C

Universidad Abierta y a Distancia de México

UNADM | DCEIT | DS | FPR 2

Unidad 2: Introducción al lenguaje C

En esta unidad hablaremos sobre la forma en

Los elementos básicos del lenguaje de programación C son: tipos

UNADM | DCEIT | DS | FPR 3

Utilizar el lenguaje de programación C para

 Identificar los tipos de datos, bibliotecas y funciones

UNADM | DCEIT | DS | FPR 4

2.1. Componentes de un programa en lenguaje C

En general, “un programa es una secuencia de instrucciones

En la unidad 1 se explicó que un programa puede ser ejecutado

De acuerdo con su creador, un programa fuente en lenguaje C,

Uno de los componentes principales de un programa en lenguaje C,

UNADM | DCEIT | DS | FPR 5

lenguaje, es decir “los programas en C usan siempre funciones de

Por convención y con el fin de aprender cómo funciona un nuevo

Ejemplo de programa hola.c

Código en lenguaje C Descripción

#include<stdio.h> De todas las bibliotecas del lenguaje C

Es una (entre otras) instrucción

Printf: es una función que se ejecuta o

UNADM | DCEIT | DS | FPR 7

paréntesis, se menciona la lista de

\n: es una secuencia de caracteres que

“Hola mundo…” : el texto que se

Los compiladores de lenguaje C ofrecen distintas directivas, sin

Una instrucción o enunciado en lenguaje C se puede definir como

UNADM | DCEIT | DS | FPR 8

Las instrucciones simples se distinguen porque terminan con

Como ejemplo de instrucciones simples tenemos la declaración de

En cambio, las instrucciones compuestas son un conjunto de

2.1.2. Palabras reservadas

Las palabras reservadas de cualquier lenguaje de programación,

En la siguiente tabla se muestran todas las palabras claves o

UNADM | DCEIT | DS | FPR 9

auto default for return switch while

Una vez que se han descrito los diferentes elementos que

2.1.3. Estructura general de un programa

Si observas el programa hola.c, la primera instrucción es la

<instrucciones para el preprocesador>

Y como se ha mencionado, se pueden incluir comentarios en

UNADM | DCEIT | DS | FPR 10

/* Directivas del procesador (bibliotecas) */

printf("Calcula el área de una circunferencia\n");

Por el momento, basta con que observes la estructura del

Ejecución del programa areaCircunferencia.c utilizando Dev-C++

UNADM | DCEIT | DS | FPR 11

2.2. Tipos de datos

En la Unidad 1 se mencionó que todos los datos que son

En general, los tipos de datos que existen, independientemente

Por el momento, sólo nos enfocaremos en los tipos de datos

Tipo Descripción Ejemplo

UNADM | DCEIT | DS | FPR 12

Su tamaño equivale a ´a´,

Es posible aumentar o disminuir la capacidad de representación

Tipo Bits Rango