I.P.E.T.

Juan XXIII

Laboratorio de Computadoras
Electrónicas

Gustavo A. Yarce

Paraná - Entre Ríos

2011
2 Gustavo A. Yarce
Índice general

1. Introducción 9
1.1. Problemas computacionales . . . . . . . . . . . . . . . . . . . . . . 9
1.2. Etapas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.1. Definición del problema . . . . . . . . . . . . . . . . . . . . 9
1.2.2. Análisis del problema . . . . . . . . . . . . . . . . . . . . . . 9
1.2.3. Programación . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.4. Prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.5. Algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3. PROGRAMACIÓN MODULAR . . . . . . . . . . . . . . . . . . . 11
1.4. Documentación de Programas . . . . . . . . . . . . . . . . . . . . . 12

2. El Lenguaje C 13
2.1. Marco histórico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2. Características . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3. Creación del programa . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4. Compilación de C . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.1. Descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5. Entorno de programación . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6. Bibliotecas estándares . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.7. Componentes del lenguaje C . . . . . . . . . . . . . . . . . . . . . . 17
2.8. Estructura de un fichero fuente . . . . . . . . . . . . . . . . . . . . 18
2.9. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.10. CONSTANTES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.11. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.11.1. Variables locales y globales . . . . . . . . . . . . . . . . . . . 20
2.12. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.12.1. Calificadores de tipo . . . . . . . . . . . . . . . . . . . . . . 22
2.13. Secuencias de escape . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.14. Inclusión de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.15. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.16. Operadores de asignación . . . . . . . . . . . . . . . . . . . . . . . . 25

3
4 Gustavo A. Yarce

2.17. Jerarquía de los operadores . . . . . . . . . . . . . . . . . . . . . . . 26

2.18. Sentencia printf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.19. Sentencia scanf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.20. Pantalla en modo texto . . . . . . . . . . . . . . . . . . . . . . . . . 31

3. Control de flujo de ejecución 35

3.1. Operadores relacionales . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2. Estructura IF...ELSE . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.1. Estructura IF...ELSE IF... . . . . . . . . . . . . . . . . . . . 36
3.3. Estructura SWITCH . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4. Control de Programas 39
4.1. Instrucción FOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.2. Instrucción WHILE . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.3. Instrucción DO...WHILE . . . . . . . . . . . . . . . . . . . . . . . . 41
Índice de figuras

5
6 Gustavo A. Yarce
Índice de tablas

2.1. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.2. Tipo signed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3. Tipo unsigned . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4. Tipo short . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5. Tipo long . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

7
Prologo
Prologo
Este documento no pretende ser un libro completo sobre programación, es una
ayuda para el alumno, para su utilización como guía de aprendizaje.
Se tiene como objetivo presentar los conceptos básicos y las características
generales del lenguaje C que posibiliten la realización de programas para la
representación de soluciones de problemas reales en una computadora.
Los temas tratados y el desarrollo que se realiza sobre ellos persiguen la enseñanza
en entornos educativos técnicos de nivel medio que necesitan conocimientos de
informática como una herramienta para la resolución de problemas.
Se prioriza la enseñanza de una metodología de programación correcta tratando
de conservar la facilidad de uso como herramienta. Siempre se considera que lo
más importante es adquirir una base de conocimientos que permita una posterior
evolución hacia conocimientos relacionados con la Electrónica y la programación.
Capítulo 1

Introducción

1.1. Problemas computacionales

Así como cada persona tiene formas de encarar un problema y su propia manera
de solucionarlo, computacionalmente hablando podemos hacer una analogía. Ante
la presentación de un problema encarar la mejor forma de resolverlo para arribar
al resultado esperado y correcto es un desafío. Para ello debemos comprender
exactamente qué se pide, qué resultados se pretenden y que restricciones y/o
condiciones existen. Para realizar lo antes dicho dividiremos la resolución de un
problema en etapas.

1.2. Etapas
1.2.1. Definición del problema
Está dada por la formulación del problema en forma correcta y completa. Esta
enunciación de lo que se desea es primordial para el éxito de la resolución.

1.2.2. Análisis del problema

A partir del estudio del problema se deberá identificar y conocer las partes
princi-pales del mismo y de esa manera determinar los siguientes conjuntos:

Datos: es la información con que contamos para resolver el problema

Resultados: es lo que se desea obtener.

Condiciones: una o más relaciones que vinculan los dos conjuntos anteriores
y que permitirán plantear la solución del problema.

9
10 Gustavo A. Yarce

1.2.3. Programación
Esta etapa consiste en obtener la solución del problema dado. Se divide en dos
subetapas:

Elección y creación del método: Se trata de buscar un procedimiento o

método general que permita resolver el problema planteado utilizando una
computadora.

Codifiación : Consiste en expresar el método elegido en un lenguaje,

llamado lenguaje de programación, que pueda se interpretado por la
computadora.

Programa
Un programa es una sucesión de instrucciones que pueden ser ejecutadas por
la PC. De modo general la PC comprende, sin traducción previa, los llamados
comando en lenguaje máquina, que son específicos del procesador.
Este tipo de lenguaje resulta ser bastante engorroso para realizar operaciones
simples. Con el fin de vencer esta dificultad, se desarrollaron los lenguajes
superiores de programación. El programador no tiene que preocuparse por la
estructura interna de la PC, ya que puede trabajar en un lenguaje relativamente
simple, transformar un determinado algoritmo en un programa adecuado.
Un lenguaje de programación lo único que realiza es la traducción escrita en
lenguaje máquina de las diferentes instrucciones escrita en un lenguaje superior.
Aquí pueden acreditarse dos procedimientos:

1. El programa usuario puede traducirse totalmente, antes de la ejecución. El

programa que realiza la traducción se llama compilador.

2. Los diferentes comandos son traducidos e, inmediatamente después ejecuta-

dos, aún antes de que el programa traductor prosiga con la siguiente ejecu-
ción. El programa de traducción que trabaja de acuerdo con este procedi-
miento, es un INTERPRETE.

1.2.4. Prueba
Esta etapa consiste en la ejecución del código del método elegido, es decir,
suministrar los datos al computador, y obtener los resultados. Luego se analizarán
los mismos determinando si son realmente los esperados. Caso contrario, deberán
analizarse las etapas previas, comenzando por la última hacia atrás, y realizar
las modificaciones necesarias, repitiendo esta proceso hasta obtener los resultados
esperados.
Laboratorio de Computadoras Electrónicas 11

1.2.5. Algoritmo
En relación al algoritmo, deseamos aún entrar con detalle en unos conceptos
que son independientes del procedimiento de notación y de la descripción formal.
En primer lugar tenemos:

FINITEZ: el algoritmo completo se tiene que representar en una sucesión

finita de caracteres.

EFECTIVIDAD: todos los pasos u operaciones que forman el algoritmo,

han de ser ejecutables. Aquí hay que pensar en las limitaciones técnicas de
la PC.

TERMINACIÓN: por razones de carácter practico, con frecuencia esta

uno interesado que, en muchos procesos, conduzca a un final.

DETERMINISMO: un algoritmo determinativo es una serie de pasos de

procesamiento, cuyo desarrollo está claramente prescrito.

EFICIENCIA: para un determinado problema, existen, generalmente,

varios algoritmos diferentes. Se distinguen por el volumen de trabajo que
hay que desarrollar para alcanzar lo mismo.

1.3. PROGRAMACIÓN MODULAR

Es un método de diseño y tiende a dividir el problema en partes perfectamente
diferenciadas que puedan ser analizadas, resueltas y puestas a punto por separa-
do. Para atacar el análisis de un problema, y siguiendo el diseño Top-Down,
se pue-den utilizar criterios de programación modular para dividirlos en partes
indepen-dientes, probando cada uno por separado y realizando su recomposición
ascen-dente. Cada una de las partes independientes se llama Módulo y para su
determinación se deben tener en cuenta los siguientes criterios:

un módulo debe corresponder a una función lógica perfectamente bien

definida.

los módulos deben ser pequeños para que sean claros y de poca complejidad.

un módulo debe tener una estructura de caja negra, es decir la salida debe
ser exclusivamente función de la entrada.

cada módulo deber tener una única entrada y una única salida.
12 Gustavo A. Yarce

1.4. Documentación de Programas

La documentación es un aspecto muy importante en la programación. Sin
embargo, generalmente los programadores principiantes suelen dejar de lado el
proceso de documentación por falta de dedicación o simple desconocimiento de
su relevancia. La documentación es todo el material anexo a un programa que
no constituye parte del código que se compila. Todo esto sirve para que el
mantenimiento, la reparación y la actualización del programa sean rápidas y
seguras. En el caso de que estas tareas deban desarrollarlas otro programador
la documentación será imprescindible. Pero más aún, cuando hayan pasado
varios meses de hecho el programa, para usted mismo será imprescindible la
documentación porque ya no podrá recordar claramente lo que hizo y le constará
mucho volver a entender el programa para poder hacer las modificaciones
necesarias. La documentación puede realizarse en el mismo archivo de texto del
programa mediante comentarios. Los comentarios poseen una sintaxis particular y
son totalmente ignorados por el compilador. Esta documentación es denominada
Interna ya que se encuentra en el mismo archivo de texto del programa. Por otra
parte, cualquier tipo de información que no se encuentre en el mismo programa
se denomina documentación externa. La documentación externa puede consistir
por ejemplo en gráficas, texto explicativo, manual de usuario, algoritmos en
pseudocódigo, etc.
Para convertir el algoritmo en un programa, se ha mostrado como muy adecuada
la utilización de los llamados diagramas de flujo.Un diagrama de flujo es una
representación gráfica del programa, con la ayuda de símbolos.
Capítulo 2

El Lenguaje C

2.1. Marco histórico

El lenguaje C fue creado entre 1970 y 1972 por Brian KERNIGHAN y
Dennis RITCHIE para escribir el código del sistema operativo UNIX. Desde su
nacimiento se fue implantando como el lenguaje de programación de sistemas
favorito para muchos programadores, sobre todo por ser un lenguaje que conjugaba
la abstracción de los lenguajes de alto nivel con la eficiencia del lenguaje máquina.
Los programadores de sistemas que trabajaban sobre MS-DOS y Macintosh
también utilizaban C, con lo cual la práctica totalidad de aplicaciones de sistema
para microordenadores y para sistemas UNIX está escrito en este lenguaje. En
1983 el lenguaje C se convierte en un estándar internacional ANSI C (que es el
que desarrollaremos). Este estándar incluye tanto la definición del lenguaje como
una enorme biblioteca de funciones para entrada/salida, tratamiento de textos,
matemáticas, etc.
A mediados de los ochenta se crea el C++, extensión de C orientada a objetos. El
C++ se convierte en estándar ISO en 1998. En el momento actual, el lenguaje C
no va a modificarse más. Será el C++ el que incorporará nuevos cambios.

2.2. Características
El lenguaje C tiene muy pocas reglas sintácticas, sencillas de aprender. Su
léxico es muy reducido: tan solo 32 palabras. A menudo se le llama lenguaje
de medio nivel, más próximo al código máquina que muchos lenguajes de más
alto nivel. Y por eso mismo es un lenguaje muy eficiente. Permite el uso del
lenguaje ensamblador en partes del código, trabaja a nivel de bit, y permite
modificar los datos con operadores que manipulan bit a bit la información.
También se puede acceder a las diferentes posiciones de memoria conociendo su

13
14 Gustavo A. Yarce

dirección. El lenguaje C permite con facilidad la programación modular, creando

unidades independientes que pueden compilarse de forma independiente, que
pueden posteriormente enlazarse. Así, se crean funciones o procedimientos, que
se pueden compilar y almacenar, creando así bibliotecas de código ya editado y
compilado que resuelve distintas operaciones. Cada programador puede diseñar
sus propias bibliotecas, que simplifican luego considerablemente el trabajo futuro.
El ANSI C posee una amplia colección de bibliotecas de funciones estándar y
normalizadas.

2.3. Creación del programa

Se puede crear un archivo que contenga el programa completo. Se puede usar
cualquier editor de textos ordinario con el que se este familiarizado. En caso de
usar un entorno Por convención el nombre del archivo debe terminar con “.c” por
ejemplo: miprograma.c. El contenido del archivo deberá obedecer la sintaxis de C.

2.4. Compilación de C
En el siguiente apartado se muestran las distintas etapas que cubre el
compilador para obtener el código ejecutable:

1. Código Fuente

2. Preprocesador

3. Compilador

4. Código Ensamblador

5. Ensamblador

6. Librerías

7. Código Objeto

8. Ligador

9. Código Ejecutable
Laboratorio de Computadoras Electrónicas 15

2.4.1. Descripción
El proceso puede ser el globalmente dividido en varios programas:
- Preprocesador: el proceso de archivo de origen antes de la compilación. Que,
por ejemplo, controlar y sustituir los archivos de macros e incluir en su fuente. -
Compilador: transformar su archivo de origen en el código de ensamble (procesador
de lenguaje humanamente legible) - Ensamblador: toma el código de ensamble
y generar código legible por máquina (código objeto binario) - Linker: reúne y
resuelve objeto códigos juntos para crear un único ejecutable.

2.5. Entorno de programación

Un entorno de programación incluye todas las distintas herramientas de
programación necesarias para trabajar con un lenguaje de programación en
particular. El entorno de C incluye los siguientes componentes:

Editores de texto: Permite introducir y modificar el código fuente C.

Administrador de proyectos: Un Proyecto es un centro para la gestión los

archivos de origen y diferentes opciones. Le ayuda a navegar a través de
su código y configurar fácilmente los distintos parámetros, como el tipo de
programa que está haciendo (GUI, consola, DLL...).

El preprocesador: Transforma el programa fuente, convirtiéndolo en otro

archivo fuente predigerido. Las transformaciones incluyen:

• Eliminar los comentarios.

• Incluir en el fuente el contenido de los ficheros declarados con #include
<fichero>(a estos ficheros se les suele llamar cabeceras)
• Sustituir en el fuente las macros declaradas con #define (ej. #define
CIEN 100)

El compilador: Convierte el código fuente entregado por el preprocesador en

un archivo en lenguaje máquina: fichero objeto, en un código que comprende
el ordenador (código máquina). Algunos compiladores pasan por una fase
intermedia en lenguaje ensamblador.

El enlazador o linkeador: Un fichero objeto es código máquina, pero no se

puede ejecutar, porque le falta código que se encuentra en otros archivos
binarios. El enlazador genera el ejecutable binario, a partir del contenido de
los ficheros objetos y de las bibliotecas.
16 Gustavo A. Yarce

Depurador o debugger: Habitualmente los programas no se ejecutan

correctamente la primera vez después de compilarlos. Mientras unos errors
son fáciles de encontrar y corregir, otros pueden ser más difíciles de encontrar
debido a la complejidad de los programas o inexperiencia del programador.
El depurador o debugger es una herramienta compleja que nos puede ayudar
a rastrear el código y corregir esos errores.

Las bibliotecas contienen el código de funciones precompiladas, a las que el archivo

fuente llama (por ejemplo printf).

El programa editado en C se llama fichero fuente. El archivo donde se almacena

ese código tendrá un nombre (el que se quiera) y la extensión .cpp, o .c. Un
programa no es más que archivo de texto. Al compilar, del fichero fuente se llega
al código máquina, con el mismo nombre que el archivo donde está el código fuente,
y con la extensión .obj. Casi con toda probabilidad en código fuente hará uso de
funciones que están ya definidas y precompiladas en las bibliotecas. Ese código
precompilado está en archivos con la extensión .lib. Desde luego, para hacer uso
de una función predefinida, es necesario conocer su existencia y tener localizada
la biblioteca donde está precompilada; eso es parte del aprendizaje de un lenguaje
de programación, aunque también se disponen de grandes índices de funciones, de
fácil acceso para su consulta. Con el archivo .obj y los necesarios .lib que se deseen
emplear, se procede al linkado que genera un fichero ejecutable con la extensión
.exe.

Ejemplo de programa en C

#include <stdio.h>
main()
{
/* Escribe un mensaje */
printf (‘‘Hola, mundo\n’’);
}

2.6. Bibliotecas estándares

El lenguaje C es muy simple. Carece de tipos y servicios que forman parte
de otros lenguajes. No tiene tipo booleano, ni manejo de cadenas, ni manejo de
memoria dinámica.
Laboratorio de Computadoras Electrónicas 17

No obstante, el estándar de C define un conjunto de bibliotecas de funciones,

que necesariamente vienen con todo entorno de compilación de C y que satisfacen
estos servicios elementales.
Las interfaces de estos servicios vienen definidas en unos ficheros cabeceras
(header files). El nombre de estos ficheros suele terminar en .h

Algunos de los servicios proporcionados por las bibliotecas estándares son:

entrada y salida de datos (stdio.h)

manejo de cadenas (string.h)

memoria dinámica (stdlib.h)

rutinas matemáticas (math.h)

2.7. Componentes del lenguaje C

Estructuras de datos

literales

tipos básicos (todos numéricos)

tipos enumerados

tipos estructurados (struct, union)

punteros y vectores

Construcciones algorítmicas

construcciones condicionales (if,switch)

construcciones iterativas(while,for,do...while)

subrutinas (funciones)

Además de lo anterior, el C tiene otros elementos:

comentarios
18 Gustavo A. Yarce

inclusión de ficheros

macros

compilación condicional

2.8. Estructura de un fichero fuente

Un fichero fuente en lenguaje C tendrá esta estructura típica:

#include <biblioteca1.h>
#include <biblioteca2.h>
... declaraciones de funciones ...

... definiciones (cuerpos de funciones) ...

... declaraciones de variables globales ...

main()
{
... cuerpo del main ...
}

... otras definiciones de funciones ...

main es simplemente una función más del programa, con la particularidad de

que es el punto de entrada al programa.

2.9. Comentarios
En C, tienen la forma /* cualquier texto */

2.10. CONSTANTES
Se define a una constante, como un elemento cuyo valor que no puede alterarse
en el transcurso de la ejecución de un algoritmo. Por ejemplo: 123, ’López’, 3.14459.

Las constantes mantienen su valor a lo largo de todo el programa.

Laboratorio de Computadoras Electrónicas 19

Para indicar al compilador que se trata de una constante, usaremos la directiva

#define:

# define <identificador> <valor>

Observa que no se indica el punto y coma de final de sentencia ni tampoco el

tipo de dato.
La directiva #define no sólo nos permite sustituir un nombre por un valor numéri-
co, sinó también por una cadena de caracteres. El valor de una constante no puede
ser modificado de ninguna manera.

Ejemplo 2.1 Constantes

/* Uso de las constantes */
#include <stdio.h>
#define pi 3.1416
#define escribe printf
main() /* Calcula el perímetro */
{
int r;
escribe("Introduce el radio: ");
scanf("%d",&r);
escribe("El perímetro es: %f",2*pi*r);
}

2.11. Variables
En un programa existen otros elementos cuyo valor cambia durante la ejecución
del mismo, llamados variables.
Una variable es un elemento o lugar asociado a un valor el que puede variar con-
forme se ejecuta el algoritmo, se representa por un nombre que identifica a una
posición de memoria donde puede asignarse o almacenarse un único valor por vez.
Para proponer el nombre de una variable observaremos tres reglas simples:

1. Utilizar sólo letras y/o dígitos, comenzando siempre con una letra.

2. No utilizar las palabras claves o reservadas del lenguaje de codificación (por

ahora, no endremos incovenientes en este aspecto, pues usaremos diagramas
20 Gustavo A. Yarce

de flujo); o para las funciones internas o predefinidas: RC, SEN, TRUNC,

LN, etc.

3. No hacer distinción entre mayúsculas y minúsculas. Esto implica que

VENTA, venta y Venta, constituyen en el algoritmo la misma variable.

Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una
variable, primero tiene que ser declarada:

[calificador] <tipo> <nombre>

Es posible inicializar y declarar más de una variable del mismo tipo en la misma
sentencia:

[calificador] <tipo> <nombre1>,<nombre2>=<valor>,<nombre3>=<valor>

Ejemplo 2.2 Variables

/* Uso de las variables */

#include <stdio.h>
#include <conio2.h>

main() /* Suma dos valores */

{
int num1=4,num2,num3=6;
printf("El valor de num1 es %d",num1);
printf("\nEl valor de num3 es %d",num3);
num2=num1+num3;
printf("\nnum1 + num3 = %d",num2);
getch();
}

2.11.1. Variables locales y globales

Las variables pueden ser de dos tipos según el lugar en que las declaremos:
globales o locales.

La variable global se declara antes de la main( ). Puede ser utilizada en cual-

quier parte del programa y se destruye al finalizar éste.
Laboratorio de Computadoras Electrónicas 21

La variable local se declara después de la main( ), en la función en que vaya

a ser utilizada. Sólo existe dentro de la función en que se declara y se destruye al
finalizar dicha función.

Ejemplo 2.3 Variables locales y globales

/* Declaración de variables */

#include <stdio.h>
#include <conio2.h>

int a;
main() /* Muestra dos valores */
{
int b=4;
printf("b es local y vale %d",b);
a=5;
printf("\na es global y vale %d",a);
getch)();
}

2.12. Tipos de datos

En C existen básicamente cuatro tipos de datos, aunque como se verá después,
podremos definir nuestros propios tipos de datos a partir de estos cuatro. A
continuación se detalla su nombre, el tamaño que ocupa en memoria y el rango de
sus posibles valores.

Tipo Tamaño Rango de Valores

char 1 byte -128 a 127
int 2 bytes -32768 a 32767
float 4 bytes 3.4 E-38 a 3.4 E+38
double 8 bytes 1.7 E-308 a 1.7 E+308

Tabla 2.1: Tipos de datos

22 Gustavo A. Yarce

2.12.1. Calificadores de tipo

Los calificadores de tipo tienen la misión de modificar el rango de valores de
un determinado tipo de variable. Estos calificadores son cuatro:

signed: Le indica a la variable que va a llevar signo. Es el utilizado por defecto.

Tipo Tamaño Rango de Valores
signed char 1 byte -128 a 127
signed int 2 bytes -32768 a 32767

Tabla 2.2: Tipo signed

unsigned: Le indica a la variable que no va a llevar signo (valor absoluto).

Tipo Tamaño Rango de Valores

unsigned char 1 byte 0 a 255
unsigned int 2 bytes 0 a 65535

Tabla 2.3: Tipo unsigned

short: Rango de valores en formato corto (limitado). Es el utilizado por defecto.

Tipo Tamaño Rango de Valores

short char 1 byte -128 a 127
short int 2 bytes -32768 a 32767

Tabla 2.4: Tipo short

long: Rango de valores en formato largo (ampliado).

Tipo Tamaño Rango de Valores

long int 4 bytes -2.147.483.648 a 2.147.483.647
long double 10 bytes -3.36 E-4932 a 1.18 E+4932

Tabla 2.5: Tipo long

10mm
Laboratorio de Computadoras Electrónicas 23

2.13. Secuencias de escape

Ciertos caracteres no representados gráficamente se pueden representar
mediante lo que se conoce como secuencia de escape.
A continuación vemos una tabla de las más significativas:
\n salto de línea
\b retroceso
\t tabulación horizontal
\v tabulación vertical
\\ contrabarra
\f salto de página
\’apóstrofe
\" comillas dobles
\0 fin de una cadena de caracteres

/* Uso de las secuencias de escape */

#include <stdio.h>
#include <conio2.h>

main() /* Escribe diversas sec. de escape */

{
printf("Me llamo \"Nemo\" el grande");
printf("\nDirección: C\\ Mayor 25");
printf("\nHa salido la letra \’L\’");
printf("\nRetroceso\b");
printf("\n\tEsto ha sido todo");
getch();
}

2.14. Inclusión de archivos

En la programación en C es posible utilizar funciones que no estén incluidas
en el propio programa. Para ello utilizamos la directiva #include, que nos permite
añadir librerías o funciones que se encuentran en otros ficheros a nuestro programa.

Para indicar al compilador que vamos a incluir ficheros externos podemos ha-
cerlo de dos maneras (siempre antes de las declaraciones).
24 Gustavo A. Yarce

1. Indicándole al compilador la ruta donde se encuentra el fichero.

#include "misfunc.h"
#include "c:\includes\misfunc.h"

2. Indicando que se encuentran en el directorio por defecto del compilador.

#include <misfunc.h>

2.15. Operadores aritméticos

Existen dos tipos de operadores aritméticos:

1. binarios:

+ Suma
-Resta
* Multiplicación
/ División
% Módulo (resto)

Su sintaxis es:

<variable1><operador><variable2>

2. unarios:

++ Incremento (suma 1)
- -Decremento (resta 1)
- Cambio de signo

Su sintaxis es:

<variable><operador> y al revés, <operador><variable>.

Laboratorio de Computadoras Electrónicas 25

Ejemplo 2.4 Operadores

/* Uso de los operadores aritméticos */

#include <stdio.h>
#include <conio2.h>

main() /* Realiza varias operaciones */

{
int a=1,b=2,c=3,r;
r=a+b;
printf("%d + %d = %d\n",a,b,r);
r=c-a;
printf("%d - %d = %d\n",c,a,r);
b++;
printf("b + 1 = %d",b);
getch();
}

2.16. Operadores de asignación

La mayoría de los operadores aritméticos binarios explicados en el capítulo
anterior tienen su correspondiente operador de asignación:

= Asignación simple
+= Suma
-= Resta
*= Multiplicación
/= División
%= Módulo (resto)

Con estos operadores se pueden escribir, de forma más breve, expresiones del
tipo:

n=n+3 se puede escribir n+=3

k=k*(x-2) lo podemos sustituir por k*=x-2

26 Gustavo A. Yarce

Ejemplo 2.5

/* Uso de los operadores de asignación */

#include <stdio.h>
#include <conio2.h>

main() /* Realiza varias operaciones */

{
int a=1,b=2,c=3,r;
a+=5;
printf("a + 5 = %d\n",a);
c-=1;
printf("c - 1 = %d\n",c);
b*=3;
printf("b * 3 = %d",b);
getch();
}

2.17. Jerarquía de los operadores

Será importante tener en cuenta la precedencia de los operadores a la hora de
trabajar con ellos:

( ) Mayor precedencia
++, - -
*, /, %
+, -Menor precendencia

Las operaciones con mayor precedencia se realizan antes que las de menor pre-
cedencia.
Si en una operación encontramos signos del mismo nivel de precedencia, dicha
operación se realiza de izquierda a derecha. A continuación se muestra un ejemplo
sobre ello:

a*b+c/d-e

1. a*b resultado = x

2. c/d resultado = y
Laboratorio de Computadoras Electrónicas 27

3. x+y resultado = z

4. z-e

Fijarse que la multiplicación se resuelve antes que la división ya que está situada
más a la izquierda en la operación. Lo mismo ocurre con la suma y la resta.

Ejemplo 2.6
/* Jerarquía de los operadores */

#include <stdio.h>
#include <conio2.h>

main() /* Realiza una operación */

{
int a=6,b=5,c=4,d=2,e=1,x,y,z,r;
x=a*b;
printf("%d * %d = %d\n",a,b,x);
y=c/d;
printf("%d / %d = %d\n",c,d,y);
z=x+y;
printf("%d + %d = %d\n",x,y,z);
r=z-e;
printf("%d = %d",r,a*b+c/d-e);
getch();
}

2.18. Sentencia printf

La rutina printf permite la aparición de valores numéricos, caracteres y cadenas
de texto por pantalla.
El prototipo de la sentencia printf es el siguiente:

printf(control,arg1,arg2...);

En la cadena de control indicamos la forma en que se mostrarán los argumentos

posteriores. También podemos introducir una cadena de texto ( sin necesidad de
argumentos ), o combinar ambas posibilidades, así como Secuencias de escape
(2.13).
En el caso de que utilicemos argumentos deberemos indicar en la cadena de control
28 Gustavo A. Yarce

tantos modificadores como argumentos vayamos a presentar.

El modificador está compuesto por el caracter

Ejemplo 2.7
/* Uso de la sentencia printf() 1. */

#include <stdio.h>
#include <conio2.h>

main() /* Saca por pantalla una suma */

{
int a=20,b=10;
printf("El valor de a es %d\n",a);
printf("El valor de b es %d\n",b);
printf("Por tanto %d+%d=%d",a,b,a+b);
getch();
}

Los modificadores más utilizados son:

%c Un único caracter
%d Un entero con signo, en base decimal
%u Un entero sin signo, en base decimal
%o Un entero en base octal
%x Un entero en base hexadecimal
%e Un número real en coma flotante, con exponente
%f Un número real en coma flotante, sin exponente
%s Una cadena de caracteres
%p Un puntero o dirección de memoria

Ejemplo 2.8

/* Uso de la sentencia printf() 2. */

#include <stdio.h>
#include <conio2.h>

main() /* Modificadores 1 */
{
Laboratorio de Computadoras Electrónicas 29

char cad[]="El valor de";

int a=-15;
unsigned int b=3;
float c=932.5;
printf("%s a es %d\n",cad,a);
printf("%s b es %u\n",cad,b);
printf("%s c es %e o %f",cad,c,c);
getch();
}

El formato completo de los modificadores es el siguiente:

% [signo] [longitud] [.precisión] [l/L] conversión

Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso

utilizaremos el signo menos, o a la derecha ( por defecto ).

Longitud: especifica la longitud máxima del valor que aparece por pantalla.
Si la longitud es menor que el número de dígitos del valor, éste aparecerá
ajustado a la izquierda.

Precisión: indicamos el número máximo de decimales que tendrá el valor.

l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es

de tipo double.

Ejemplo 2.9
/* Uso de la sentencia printf() 3. */

#include <stdio.h>
#include <conio2.h>

main() /* Modificadores 2 */
{
char cad[ ]="El valor de";
int a=25986;
long int b=1976524;
float c=9.57645;
printf("%s a es %9d\n",cad,a);
30 Gustavo A. Yarce

printf("%s b es %ld\n",cad,b);
printf("%s c es %.3f",cad,c);
getch();
}

2.19. Sentencia scanf

La rutina scanf permite entrar datos en la memoria del ordenador a través del
teclado.
El prototipo de la sentencia scanf es el siguiente:

scanf(control,arg1,arg2...);

En la cadena de control indicaremos, por regla general, los modificadores 2.18

que harán referencia al tipo de dato de los argumentos. Al igual que en la senten-
cia printf los modificadores 2.18 estarán formados por el caracter % seguido de un
caracter de conversión. Los argumentos indicados serán, nuevamente, las variables.

La principal característica de la sentencia scanf es que necesita saber la

posición de la memoria del ordenador en que se encuentra la variable para poder
almacenar la información obtenida. Para indicarle esta posición utilizaremos el
símbolo ampersand ( & ), conocido como operador de dirección, que colocaremos
delante del nombre de cada variable. ( Esto no será necesario en los arrays ).

Ejemplo 2.10
/* Uso de la sentencia scanf(). */

#include <stdio.h>
#include <conio2.h>

main() /* Solicita dos datos */

{
char nombre[10];
int edad;
printf("Introduce tu nombre: ");
scanf("%s",nombre);
printf("Introduce tu edad: ");
Laboratorio de Computadoras Electrónicas 31

scanf("%d",&edad);
getch();
}

2.20. Pantalla en modo texto

Las funciones añadidas para manejo de la pantalla en Lenguaje C, se encuen-
tran accesibles a través del fichero de cabecera c̈onio2.h.̈

En él encontramos funciones como:

gotoxy - Desplaza el cursor a ciertas coordenadas.

textcolor - Cambia el color del texto (el de primer plano).

textbackground - Cambia el color del texto (el de fondo).

textattr - Cambia el color (fondo y primer plano) del texto.

cprintf - Escribe un mensaje en color.

cputs - Escribe una cadena de texto en color.

clrscr - Borra la pantalla.

clreol - Borra hasta el final de la línea actual.

textmode - Cambia el modo de pantalla.

getche - Espera hasta que se pulse una tecla, y la muestra en pantalla.

getch - Espera hasta que se pulse una tecla, pero no la muestra en pantalla.

kbhit - Comprueba si se ha pulsado alguna tecla (pero no espera).

wherex - Devuelve la coordenada ẍ¨(columna) en que se encuentra el cursor.

wherey - Devuelve la coordenada ÿ¨(fila) en que se encuentra el cursor.

window - Permite crear una ventana dentro de la pantalla. A partir de

entonces, las órdenes como g̈otoxys̈e referirán sólo a esa ventana, no al total
de la pantalla.
32 Gustavo A. Yarce

Los colores de la pantalla se indican por números. Por ejemplo: 0 es el negro,

1 es el azul oscuro, 2 el verde, 3 el azul claro, 4 el rojo, etc. Aun así, para no tener
que recordarlos, tenemos definidas constantes con su nombre en inglés:

BLACK

BLUE

GREEN

CYAN

RED

MAGENTA

BROWN

LIGHTGRAY

DARKGRAY

LIGHTBLUE

LIGHTGREEN

LIGHTCYAN

LIGHTRED

LIGHTMAGENTA

YELLOW

WHITE

Una última consideración: en MsDos sólo se pueden usar como colores de fondo
los 7 primeros: desde BLACK hasta LIGHTGRAY. Esto se puede evitar con las
pantallas VGA, a cambio de perder la posibilidad de que el texto parpadee, pero
no voy a entrar en esos detalles. El caso es que n̈ormalmentes̈i hacemos algo como

textbackground(LIGHTBLUE);

no obtendremos los resultados esperados, sino que será como si hubiésemos

utilizado el equivalente en el rango de 0 a 7:
Laboratorio de Computadoras Electrónicas 33

textbackground(BLUE);

Ejemplo 2.11 #include <conio2.h> /* Para funciones de pantalla */

int i,j; /* Para los bucles "for" */

main()
{
textbackground(BLUE); /* Fondo de la pantalla en azul */
clrscr(); /* Borro la pantalla */
for(i=0; i<=1; i++) /* Dos columnas */
for(j=0; j<=15; j++) /* Los 16 colores */
{
gotoxy(10+ 40*i , 3+j); /* Coloco el cursor */
textcolor(j); /* Elijo el color */
if (j == 0) /* Si el color es 0 (negro) */
textbackground(LIGHTGRAY); /* dejo fondo gris */
else /* Si es otro color */
textbackground(BLACK); /* dejo fondo negro */
cprintf(" Este es el color %d ",j); /* Escribo en color */
}
getch(); /* Final: espero a que se pulse una tecla, sin mostrarla */
}
34 Gustavo A. Yarce
Capítulo 3

Control de flujo de ejecución

Este tipo de sentencias permiten variar el flujo del programa en base a unas
determinadas condiciones. Existen varias estructuras diferentes:

3.1. Operadores relacionales

Los operadores relacionales se utilizan para comparar el contenido de dos va-
riables.

En C existen seis operadores relacionales básicos:

>Mayor que
<Menor que
>= Mayor o igual que
<= Menor o igual que
== Igual que
!= Distinto que

El resultado que devuelven estos operadores es 1 para Verdadero y 0 para Falso.

Si hay más de un operador se evalúan de izquierda a derecha. Además los

operadores == y != están por debajo del resto en cuanto al orden de precedencia.

3.2. Estructura IF...ELSE

Sintaxis:

35
36 Gustavo A. Yarce

if (condición)
sentencia1;
else
sentencia2;

La parte del else es optativa. La condicón se evalúa, si es verdadera, la

sentencia1 se ejecuta. Si la condición es falsa y si existe un else, la sentencia2
se ejecuta.

Ejemplo 3.1 /* Uso de la sentencia condicional IF. */

#include <stdio.h>

main() /* Simula una clave de acceso */

{
int usuario,clave=18276;
printf("Introduce tu clave: ");
scanf("%d",&usuario);
if(usuario==clave)
printf("Acceso permitido");
else
printf("Acceso denegado");
}

3.2.1. Estructura IF...ELSE IF...

Sintaxis:

if (condición) sentencia1;
else if (condición) sentencia2;
else if (condición) sentencia3;
else sentencia4;

Esta secuencia de instrucciones if es la forma mas general de escribir una

decisión múltiple.
Las condiciones se evaluan en orden; si cualquier condición es verdadera, la
sentencia asociada a ella se ejecuta, y esto termina toda la cadena. La sentencia
puede ser una única sentencia o un grupo de sentencias contenidas entre un par
de llaves.
Laboratorio de Computadoras Electrónicas 37

Ejemplo 3.2
/* Uso de la sentencia condicional ELSE...IF. */

#include <stdio.h>

main() /* Escribe bebé, niño o adulto */

{
int edad;
printf("Introduce tu edad: ");
scanf("%d",&edad);
if (edad<1)
printf("Lo siento, te has equivocado.");
else if (edad<3) printf("Eres un bebé");
else if (edad<13) printf("Eres un niño");
else printf("Eres adulto");
}

switch (variable){
case contenido_variable1: sentencias;
case contenido_variable1: sentencias;
default:

3.3. Estructura SWITCH

Esta estructura se suele utilizar en los menús, de manera que según la opción
seleccionada se ejecuten una serie de sentencias.
Su sintaxis es:

switch (variable){
case contenido_variable1:
sentencias;
break;
case contenido_variable2:
sentencias;
break;
default:
sentencias;
}
38 Gustavo A. Yarce

Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves,
ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La variable
evaluada sólo puede ser de tipo entero o caracter. default ejecutará las sentencias
que incluya, en caso de que la opción escogida no exista.

Ejemplo 3.3
/* Uso de la sentencia condicional SWITCH. */

#include <stdio.h>

main() /* Escribe el día de la semana */

{
int dia;
printf("Introduce el día: ");
scanf("%d",&dia);
switch(dia){
case 1: printf("Lunes"); break;
case 2: printf("Martes"); break;
case 3: printf("Miércoles"); break;
case 4: printf("Jueves"); break;
case 5: printf("Viernes"); break;
case 6: printf("Sábado"); break;
case 7: printf("Domingo"); break;
}
}
Capítulo 4

Control de Programas

La mayor parte de los programas incluyen repeticiones o ciclos. Los bucles son
estructuras que permiten ejecutar partes del código de forma repetida mientras se
cumpla una condición.

Esta condición puede ser simple o compuesta de otras condiciones unidas por
operadores lógicos. Según cómo queramos que se controle ese bucle, tenemos tres

posibilidades, que básicamene se pueden describir como:

for: La orden se repite desde que una variable tiene un valor inicial hasta
que alcanza otro valor final.

while: Repite una sentencia mientras que sea cierta la condición que
indicamos. La condición se comprueba antes de realizar la sentencia.

do..while: Igual, pero la condición se comprueba después de realizar la

sentencia.

Las diferencias son: for normalmente se usa para algo que se repite un número
fijo de veces, mientras que "while"se basa en comprobar si una condición es cierta,
se repetirá un número mienstras se cumpla la condición.

4.1. Instrucción FOR

Su sintaxis es:

for (inicialización;condición;incremento)
{

39
40 Gustavo A. Yarce

sentencia1;
sentencia2;
}

La inicialización indica una variable (variable de control) que condiciona( 3.1)

la repetición del bucle. Si hay más, van separadas por comas:

Ejemplo 4.1
/* Uso de la sentencia FOR. */

#include <stdio.h>
#include <conio2.h>

main() /* Escribe la tabla de multiplicar */

{
int num,x,result;
printf("Introduce un número: ");
scanf("%d",&num);
for (x=0;x<=10;x++)
{
result=num*x;
printf("\n%d por %d = %d\n",num,x,result);
}
getch();
}

Pueden utilizarse dos condiciones en un bucle

for(Inicialización1,inicialización2;condición1,condición2;incremento1,incremento2)

El programa sigue avanzando,no se sale del bucle for, hasta que se cumplen las
dos condiciones.

4.2. Instrucción WHILE

Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta
no se cumple, el programa no entrará en el bucle.
Naturalmente, si en el interior del bucle hay más de una sentencia, éstas deberán
Laboratorio de Computadoras Electrónicas 41

ir entre llaves para que se ejecuten como un bloque.

Su sintaxis es:

while (condición) sentencia;

Ejemplo 4.2
/* Uso de la sentencia WHILE. */

#include <stdio.h>
#include <conio2.h>

main() /* Escribe los números del 1 al 10 */

{
int numero=1;
while(numero<=10)
{
printf("%d\n",numero);
numero++;
}
getch();
}

4.3. Instrucción DO...WHILE

Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple,
el programa vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las sentencias while y do...while es que con la segunda el
cuerpo del bucle se ejecutará por lo menos una vez. Su sintaxis es:

do{
sentencia1;
sentencia2;
}while (condición);

Ejemplo 4.3
/* Uso de la sentencia DO...WHILE. */
42 Gustavo A. Yarce

#include <stdio.h>
#include <conio2.h>

main() /* Muestra un menú si no se pulsa 4 */

{
char seleccion;
do{
printf("1.- Comenzar\n");
printf("2.- Abrir\n");
printf("3.- Grabar\n");
printf("4.- Salir\n");
printf("Escoge una opción: ");
seleccion=getchar();
switch(seleccion){
case ’1’:printf("Opción 1");
break;
case ’2’:printf("Opción 2");
break;
case ’3’:printf("Opción 3");
}

}while(seleccion!=’4’);
}