Apunte Herramientas Informaticas

UNIVERSIDAD TECNOLÓGICA
NACIONAL
FACULTAD REGIONAL
CÓRDOBA
TECNICATURA DE MECATRÓNICA
HERRAMIENTAS INFORMÁTICAS
Ing. Centeno, Carlos

Ing. Avramovich, Javier A.
A la memoria de mi padre; Boris Avramovich, quien
fuera mi primer maestro en el mundo de la
electrónica.
+
Universidad Tecnológica Nacional Tecnicatura de Mecatrónica
Facultad Regional Córdoba
TABLA DE CONTENIDO
Tabla de Contenido ...................................................................................................................... 3
Informática. ................................................................................................................................... 7
Computadora ................................................................................................................................ 7
Arquitectura de una computadora............................................................................................. 7
Funcionamiento......................................................................................................................... 8
Flujo de datos............................................................................................................................ 9
Hardware. ................................................................................................................................... 10
Componentes básicos del Hardware.......................................................................................... 10
Placa principal......................................................................................................................... 10
Microprocesador. .................................................................................................................... 11
El coprocesador aritmético...................................................................................................... 11
La memoria. ............................................................................................................................ 11
Memoria ROM......................................................................................................................... 11
Memoria RAM. ........................................................................................................................ 11
Fuente de alimentación........................................................................................................... 12
Dispositivos de crecimiento (Slots). ........................................................................................ 12
Periféricos................................................................................................................................... 12
Tipos de periféricos................................................................................................................. 13
Otros conceptos y curiosidades .............................................................................................. 14
Software...................................................................................................................................... 14
Tipología del software................................................................................................................. 15
Los sistemas operativos. ............................................................................................................ 15
Lenguajes de Programación....................................................................................................... 16
Lenguaje de maquina:............................................................................................................. 16
Lenguaje de bajo nivel (ensambladores) ................................................................................ 16
Lenguaje de alto nivel. ............................................................................................................ 17
Características de los lenguajes de programación: ................................................................ 17
Formas del software ................................................................................................................... 17
El proceso de creación de software............................................................................................ 18
Programación. ............................................................................................................................ 18
Programas y algoritmos. ......................................................................................................... 18
Compilación. ........................................................................................................................... 18
Programación e ingeniería del software.................................................................................. 19
Objetivos de la programación ................................................................................................. 19
Concepto de "programa" ............................................................................................................ 20
Concepto de “función” ................................................................................................................ 21
Nombre, valor de retorno y argumentos de una función......................................................... 21
La función principal o función main() ...................................................................................... 23
Palabras claves del C ............................................................................................................. 23
Elementos................................................................................................................................... 24
Comentarios............................................................................................................................ 24
Identificadores......................................................................................................................... 24
Variables ................................................................................................................................. 24
Constantes .............................................................................................................................. 24
Operadores ............................................................................................................................. 24
Sentencias .............................................................................................................................. 25
Tipos ........................................................................................................................................... 26
Unidades de medida empleadas en informática......................................................................... 27
Los bytes, Kilobytes, Megabytes............................................................................................. 27
Los bits.................................................................................................................................... 27
Sistemas de numeración ............................................................................................................ 28
Ing. Prof. Avramovich, Javier A. 3

Sistema binario ....................................................................................................................... 28

Sistema Hexadecimal ............................................................................................................. 29
Diagramas de Flujo .................................................................................................................... 31
Programación Estructurada .................................................................................................... 31
Comando #include...................................................................................................................... 32
Estructuras Secuenciales ........................................................................................................... 33
Función printf() .......................................................................................................................... 33
Función scanf().......................................................................................................................... 36
Estructuras Selectiva.................................................................................................................. 38
Función if ................................................................................................................................... 38
funcion if-else ............................................................................................................................ 39
funcion if-else-if .......................................................................................................................... 41
El operador condicional ? ........................................................................................................... 42
Función switch............................................................................................................................ 43
Estructuras repetitivas ................................................................................................................ 46
Sentencia While.......................................................................................................................... 46
Sentencia Do-While.................................................................................................................... 49
Sentencia for .............................................................................................................................. 52
El operador coma (,) .............................................................................................................. 53
Sentencia Break y continue........................................................................................................ 55
Break....................................................................................................................................... 55
Continue.................................................................................................................................. 55
Sentencia goto............................................................................................................................ 57
Tipos de datos estructurados ..................................................................................................... 58
Vector o array ............................................................................................................................. 58
Consulta de un array............................................................................................................... 58
Asignación de datos a un array .............................................................................................. 59
Matriz o array bidimensional....................................................................................................... 61
Consulta.................................................................................................................................. 62
Asignación .............................................................................................................................. 62
Arreglos multidimencionales....................................................................................................... 63
Funciones ................................................................................................................................... 63
Definición de una función........................................................................................................ 64
Prototipos de una función. ...................................................................................................... 65
Llamada a una función............................................................................................................ 65
Ejemplo: .................................................................................................................................. 65
Conexión y programación del puerto paralelo............................................................................ 67
El puerto paralelo en un PC.................................................................................................... 67
El Registro de Datos. .............................................................................................................. 68
El Registro de Estado. ............................................................................................................ 68
El Registro de Control............................................................................................................. 69
Asignación de pines en el conector DB25 Hembra del puerto paralelo.................................. 70
Entradas y salidas por el puerto paralelo................................................................................ 71
Características E/S. ................................................................................................................ 71
Apéndice A - Tabla de Caracteres ASCII ................................................................................... 74
Apéndice B – Métodos de ordenamiento y búsqueda................................................................ 75
Ordenamiento. ........................................................................................................................ 75
Método de la burbuja .............................................................................................................. 75
Apéndice C – Interfase para puerto paralelo.............................................................................. 78
Introducción. ........................................................................................................................... 78
Descripción. ............................................................................................................................ 78
Lista de materiales:................................................................................................................. 78
4 Ing. Prof. Avramovich, Javier A.

Diagrama electrónico: ............................................................................................................. 79

Placa PCB:.............................................................................................................................. 79


INFORMÁTICA.
La informática es la disciplina que estudia el tratamiento automático de la información utilizando
dispositivos electrónicos y sistemas computacionales. También es definida como el
procesamiento de información en forma automática. Para ello los sistemas informáticos deben
realizar las siguientes tareas básicas:
Entrada: Captación de información.
Procesamiento o tratamiento de dicha información.
Salida: Transmisión de resultados.
El vocablo Informática proveniente del francés ‘informatique’, acuñado por el ingeniero Philippe
Dreyfus en 1962, acrónimo de las palabras ‘information’ y ‘automatique’. En lo que hoy
conocemos como informática confluyen muchas de las técnicas y de las máquinas que el
hombre ha desarrollado a lo largo de la historia para apoyar y potenciar sus capacidades de
memoria, de pensamiento y de comunicación.
La informática se utiliza en diversidad de tareas, por ejemplo: elaboración de documentos,
monitorización y control de procesos, robots industriales, telecomunicaciones, desarrollo de
juegos, aplicaciones/herramientas multimedia, etc.
En la informática convergen los fundamentos de las ciencias de la computación (hardware), la
programación y las metodologías para el desarrollo de software, la arquitectura de
computadores, las redes de datos como Internet, la inteligencia artificial, así como
determinados temas de electrónica. Se puede entender por informática a la unión sinérgica de
todo este conjunto de disciplinas.
COMPUTADORA
Una computadora (del latín ‘computare’ -calcular-), también denominada como ordenador o
computador es un sistema digital con tecnología microelectrónica, capaz de recibir y procesar
datos a partir de un grupo de instrucciones denominadas programas, y finalmente transferir la
información procesada o guardarla en algún tipo de dispositivo o unidad de almacenamiento.
La característica principal que la distingue de otros dispositivos similares, como una
calculadora no programable, es que puede realizar tareas muy diversas cargando distintos
programas en la memoria para que el procesador los ejecute.
Arquitectura de una computadora

Memoria Bus del sistema
Dispositivos de Entrada/Salida
Programa
Area de datos
001101001110011100001
011111100001010101010
011010001100111101110
001110010101100101011
Area de codigos
100110110110011100001 Registros
11110000101010101010
111100001100111101110
00001110101100101011
10101001011
111111110
Unidad de
ALU
Control
Aunque las tecnologías empleadas en las computadoras digitales han cambiado mucho desde
que aparecieron los primeros modelos en los años 40, la mayoría todavía utiliza la arquitectura

Eckert-Mauchly, publicada a principios de los años 1940 por John von Neumann pero que fue
creada por John Presper Eckert y John William Mauchly.
La arquitectura Eckert-Mauchly describe una computadora con 4 secciones principales: la
unidad lógica y aritmética (ALU), la unidad de control, la memoria, y los dispositivos de entrada
y salida (E/S). Estas partes están interconectadas por un conjunto de cables denominados
buses:
La memoria es una secuencia de celdas de almacenamiento numeradas, donde cada una es
un bit o unidad de información. La instrucción es la información necesaria para realizar lo que
se desea con el computador. Las «celdas» contienen datos que se necesitan para llevar a cabo
las instrucciones, con el computador. El número de celdas varían mucho de computador a
computador, y las tecnologías empleadas para la memoria han cambiado bastante; van desde
los relés electromecánicos, tubos llenos de mercurio en los que se formaban los pulsos
acústicos, matrices de imanes permanentes, transistores individuales a circuitos integrados con
millones de celdas en un solo chip. En general, la memoria puede ser reescrita varios millones
de veces (memoria RAM); se parece más a una pizarra que a una lápida (memoria ROM) que
sólo puede ser escrita una vez.
El procesador (también llamado Unidad central de procesamiento o CPU) consta de un típico
símbolo esquemático para una ALU: A y B son operandos; R es la salida; F es la entrada de la
unidad de control; D es un estado de la salida.
La unidad lógica y aritmética o ALU es el dispositivo diseñado y construido para llevar a cabo
las operaciones elementales como las operaciones aritméticas (suma, resta), operaciones
lógicas (Y, O, NOR), y operaciones de comparación o relacionales. En esta unidad es en donde
se hace todo el trabajo computacional.
La unidad de control sigue la dirección de las posiciones en memoria que contiene la
instrucción que el computador va a realizar en ese momento; recupera la información
poniéndola en la ALU para la operación que debe desarrollar. Transfiere luego el resultado a
ubicaciones apropiadas en la memoria. Una vez que ocurre lo anterior, la unidad de control va
a la siguiente instrucción (normalmente situada en la siguiente posición, a menos que la
instrucción sea una instrucción de salto, informando a la computadora de que la próxima
instrucción estará ubicada en otra posición de la memoria).
Los dispositivos E/S sirven a la computadora para obtener información del mundo exterior y/o
comunicar los resultados generados por el computador al exterior. Hay una gama muy extensa
de dispositivos E/S como teclados, monitores, y unidades de disco flexible o cámaras web.
Funcionamiento.
Las instrucciones que se ejecutan en un computador, no son las ricas instrucciones del ser
humano. Una computadora sólo se diseña con un número limitado de instrucciones bien
definidas. Los tipos de instrucciones típicas realizadas por la mayoría de las computadoras son
como estos ejemplos:

- Copia los contenidos de la posición de memoria 123.

- Coloca la copia en la posición 456.
- Añade los contenidos de la posición 666 a la 042.
- Coloca el resultado en la posición 013.
- Si los contenidos de la posición 999 son 0.
- Tu próxima instrucción está en la posición 345.
Las instrucciones dentro del computador se representan mediante números. Por ejemplo, el
código para copiar puede ser 001. El conjunto de instrucciones que puede realizar un
computador se conoce como lenguaje de máquina o código máquina. En la práctica, no se
escriben las instrucciones para los computadores directamente en lenguaje de máquina, sino
que se usa un lenguaje de programación de alto nivel que se traduce después al lenguaje de la
máquina automáticamente, a través de programas especiales de traducción (intérpretes y
compiladores). Algunos lenguajes de programación representan de manera muy directa el
lenguaje de máquina, como el lenguaje ensamblador (lenguajes de bajo nivel) y, por otra parte,
los lenguajes como Java, se basan en principios abstractos muy alejados de los que hace la
máquina en concreto (lenguajes de alto nivel).
Por lo tanto, el funcionamiento de un computador es en principio bastante sencillo. El
computador trae las instrucciones y los datos de la memoria. Se ejecutan las instrucciones, se
almacenan los datos y se va a por la siguiente instrucción. Este procedimiento se repite
continuamente, hasta que se apaga el computador. Los Programas de ordenador (software)
son simplemente largas listas de instrucciones que debe ejecutar el computador, a veces con
tablas de datos. Muchos programas de computador contienen millones de instrucciones que se
ejecutan a gran velocidad; un computador personal moderno puede ejecutar de 2000 a 3000
millones de instrucciones por segundo. Las capacidades extraordinarias que tienen los
computadores no se deben a su habilidad para ejecutar instrucciones complejas. Los
computadores ejecutan millones de instrucciones simples diseñadas por programadores. Hay
programadores que desarrollan grupos de instrucciones para hacer tareas comunes (por
ejemplo, dibujar un punto en la pantalla) y luego ponen dichos grupos de instrucciones a
disposición de otros programadores para que estos elaboren funciones o tareas más
complejas.
Flujo de datos.
El mapa conceptual muestra, en forma básica, como funciona el flujo de los datos en una
computadora, para luego convertirse en información útil para el usuario. Podemos notar que los
datos comúnmente fluyen según esta secuencia:
Entrada de datos o información

DMA
(Acceso Directo a Memoria)
Microprocesador Memoria RAM
Almacenamiento Salida directa

de la información de información

Ejemplos:
Entrada de datos o información: Teclado, Mouse, micrófono, escáner.
Almacenamiento de información: Disco rígido, CD, DVD, USB Drive.
Salida directa de información: Monitor, parlantes, impresora.
Existe también la entrada de datos directamente a la RAM, sin la intervención previa del
microprocesador; este modo de acceso se denomina Acceso Directo a Memoria. La memoria
RAM está en constante comunicación con el microprocesador (en el diagrama, procesamiento),
de forma mucho más rápida que cualquier otro dispositivo de almacenamiento. Finalmente la
información (los datos procesados) es almacenada en algún disco, o bien, sale directamente de
forma analógica o digital de la computadora, ya sea hacia el monitor, los altavoces la impresora
o cualquier otro dispositivo que reciba y proyecte la información.
HARDWARE.
Hardware es un neologismo proveniente del inglés definido como el conjunto de elementos
materiales que conforman una computadora, sin embargo, es usual que sea utilizado en una
forma más amplia, generalmente para describir componentes físicos de una tecnología, así el
hardware puede ser de un equipo militar importante, un equipo electrónico, un equipo
informático o un robot. En informática también se aplica a los periféricos de una computadora
tales como el disco duro, CD-ROM, disquetera (floppy), etc... En dicho conjunto se incluyen los
dispositivos electrónicos y electromecánicos, circuitos, cables, armarios o cajas, periféricos de
todo tipo y cualquier otro elemento físico involucrado.
El hardware se refiere a todos los componentes físicos (que se pueden tocar), en el caso de
una computadora personal serían los discos, unidades de disco, monitor, teclado, la placa
base, el microprocesador, etc. En cambio, el software es intangible, existe como información,
ideas, conceptos, símbolos, pero no ocupa un espacio físico, se podría decir que no tiene
sustancia. Una buena metáfora sería un libro: las páginas y la tinta son el hardware, mientras
que las palabras, oraciones, párrafos y el significado del texto (información) son el software.
Una computadora sin software sería tan inútil como un libro con páginas en blanco.
COMPONENTES BÁSICOS DEL HARDWARE.
Placa principal.
También llamada Tarjeta Madre o Motherboard es donde se encuentran las conexiones
básicas para todos los componentes de la computadora, los cuales giran en torno al
microprocesador. Es básicamente la que permite o no el futuro crecimiento de las habilidades
de cualquier computadora, una tarjeta con una arquitectura muy cerrada terminará con la vida
de todo el equipo en el momento que ésta requiera una reparación o mejora, éste fue el caso
de la mayoría de las computadoras que existieron en el pasado, como por mencionar algunas,
podemos citar a la Comodore 64, Tandy 1000 e incluso todas las XT´s y algunas 286 de IBM.
Estas se pueden clasificar en la actualidad en:
Arquitectura de 8 bits: Primeras XT.
Arquitectura ISA 8 -16 bits. La mayoría de las actuales clones.
Arquitectura EISA o MCA de 32 bits. La mayoría de las de IBM o compatibles de marca
de calidad que se venden actualmente.
En ella podemos encontrar los siguientes componentes:

Microprocesador.
Es en sí el cerebro, el cual se compone a su vez de Unidad Aritmética, lógica y de control. Esta
unidad trabaja en base a un reloj (clock) maestro que coordina la ejecución de todas las
operaciones que realiza el microprocesador.
La unidad fundamental de trabajo de este reloj es la cantidad de instrucciones que el
microprocesador puede ejecutar en un segundo. Así, un clock de 12 MHz limita al
microprocesador a realizar 12 millones de instrucciones por segundo.
La rapidez y poder de ejecución de tareas esta determinado completamente por el
microprocesador el cual subdivide a las computadoras en diferentes tipos, entre ellos algunas
ya obsoletas como son : las llamadas 8086 XT (80286, 80386, 80486) y Pentium (80586),
bautizadas así por la compañía fabricante INTEL la cual ha proveído desde las primeras PC’s y
hasta hoy a la mayoría de las computadoras con sus modelos de cerebro.
Sin embargo Intel no es ya el único fabricante de microprocesadores para las computadoras
personales, compiten también en el mercado compañías como Cyrix, AMD, Power Pc, Digital
Equipment, etc. Sin embargo, aunque en competencia, la mayoría de esas compañías ofrecen
microprocesadores equivalentes a los estándares ofrecidos serie a serie por Intel Corporation.
El modelo de un microprocesador nos indica sobre todo el poder o sea el potencial de tareas
que un microprocesador puede ejecutar a la vez y su reloj nos indica su velocidad de
sincronización con la cual éstas son realizadas. Así entre una computadora 286 y una 486 hay
una notable diferencia de poder y velocidad incomparables ya que a la primera no podremos
agregarle u ordenarle tantas cosas como a la segunda; y por otro lado entre una 486 de 25
Mhz y una 486 de 50 Mhz estamos hablando que las dos tienen el mismo poder, pero la
segunda dobla la velocidad a la primera.
El coprocesador aritmético.
Es un microprocesador de instalación opcional, también denominado unidad de punto flotante
que auxilia al microprocesador en el uso eficiente de programas de graficación, cálculos
matemáticos complejos y diseño entre tantos, lo cual al especializarse en dichas funciones
acelera la velocidad con que una computadora puede responder a necesidades tan
sofisticadas.
En la actualidad ya vienen incluidos en todas las computadoras nuevas, ya que el poder que
exigen no puede descartar la falta de éste coprocesador.
La memoria.
Es la capacidad de almacenar información, su unidad de almacenamiento es el BYTE que es la
capacidad de almacenar un carácter, una letra, número o cualquier símbolo como #,$,&, etc.
Se clasifican en memoria ROM y RAM.
Memoria ROM.
Esta memoria es sólo de lectura (Read Only Memory), y sirve para almacenar el programa
básico de iniciación, instalado desde fábrica. Este programa entra en función en cuanto es
encendida la computadora y su primer función es la de reconocer los dispositivos.
Memoria RAM.
Esta es la denominada memoria de acceso aleatorio (Random Access Memory) o sea, como
puede leerse también puede escribirse en ella, tiene la característica de ser volátil, esto es, que
sólo opera mientras esté encendida la computadora. En ella son almacenadas tanto las

instrucciones que necesita ejecutar el microprocesador como los datos que introducimos y
deseamos procesar, y los resultados obtenidos de esto.
Como puede usted ver, si al momento de apagar nuestra computadora se volatilizan nuestro
datos almacenados en la memoria RAM, requerimos por lo tanto, de medios que
almacenamiento por tiempo indefinido que nos garanticen la seguridad y confiabilidad de
nuestros datos, o sea, otro tipo de memorias, que definiremos como memorias auxiliares, entre
ella ubicamos al disco duro, los disquete, los CD/DVD, los pen drive, etc.
Fuente de alimentación.
Tanto el microprocesador como todos los circuitos que forman los dispositivos se alimentan de
cantidades de energía bien definidas y precisas, o sea necesitan de una fuente que les
suministre y regule la cantidad necesaria ya que cualquier variación en el voltaje podría ser
suficiente para quemar dichos circuitos.
Dispositivos de crecimiento (Slots).

Son las puertas que están listas para recibir la conexión de cualquier otro aparato o tarjeta que
permita ampliar las capacidades de trabajo de una computadora, y son el punto más importante
para asegurarnos haber hecho una buena inversión. Estos son las ranuras de expansión y los
puertos.
Los puertos son los puntos de conexión que ya vienen con la computadora y que permiten la
instalación rápida de los dispositivos más comunes, como lo son el teclado, la impresora, el
monitor, etc.
PERIFÉRICOS.
Se denominan periféricos tanto a las unidades o dispositivos a través de los cuales la
computadora se comunica con el mundo exterior, como a los sistemas que almacenan o
archivan la información, sirviendo de memoria auxiliar de la memoria principal.
Se entenderá por periférico a todo conjunto de dispositivos que, sin pertenecer al núcleo
fundamental de la computadora, formado por la CPU y la memoria central, permitan realizar
operaciones de entrada/salida (E/S) complementarias al proceso de datos que realiza la CPU.
Estas tres unidades básicas en un computador, CPU, memoria central y el subsistema de E/S,
están comunicadas entre sí por tres buses o canales de comunicación: el bus de direcciones,
para seleccionar la dirección del dato o del periférico al que se quiere acceder, el bus de
control, básicamente para seleccionar la operación a realizar sobre el dato (principalmente
lectura, escritura o modificación) y el bus de datos, por donde circulan los datos.
A pesar de que el término periférico implica a menudo el concepto de “adicional pero no
esencial”, muchos de ellos son elementos fundamentales para un sistema informático. El
teclado y el monitor, imprescindibles en cualquier computadora personal de hoy en día (no lo
fueron en los primeros computadores), son posiblemente los periféricos más comunes, y es
posible que mucha gente no los considere como tal debido a que generalmente se toman como
parte necesaria de una computadora. El mouse es posiblemente el ejemplo más claro de este
aspecto. Hace menos de 20 años no todos las computadora personales incluían este
dispositivo. El sistema operativo MS-DOS, el más común en esa época, tenía una interfaz de
línea de comandos para la que no era necesario el empleo de un mouse, todo se hacía
mediante comandos de texto. Fue con la popularización de Finder, sistema operativo de la
Macintosh de Apple y la posterior aparición de Windows cuando el mouse comenzó a ser un
elemento imprescindible en cualquier hogar dotado de una computadora personal. Actualmente
existen sistemas operativos con interfaz de texto que tampoco hacen uso del mouse como, por
ejemplo, algunos sistemas básicos de UNIX y Linux.

Tipos de periféricos
Los periféricos pueden clasificarse en 4 categorías principales:
Periféricos de entrada: Captan y envían los datos al dispositivo que los procesará. Son los
que introducen datos externos a la computadora para su posterior tratamiento por parte de la
CPU. Estos datos pueden provenir de distintas fuentes, siendo la principal un ser humano.
Los periféricos de entrada más habituales son:
Teclado
Mouse
Cámara web
Escáner
Micrófono
Conversor Analógico digital
Escáner de código de barras
Joystick
Tableta digitalizadora
Pantalla táctil
Periféricos de salida: Son dispositivos que muestran o proyectan información hacia el exterior
del ordenador. La mayoría son para informar, alertar, comunicar, proyectar o dar al usuario
cierta información, de la misma forma se encargan de convertir los impulsos eléctricos en
información legible para el usuario. Sin embargo, no todos este tipo de periféricos es
información para el usuario. Cabe aclarar también que ciertos periféricos de salida pueden ser
duales, o sea, de entrada y salida.
Los periféricos de salida más habituales son:
Monitor
Impresoras
Altavoces
Auriculares
Fax
Periféricos de almacenamiento: Son los dispositivos que almacenan datos e información por
bastante tiempo. La memoria RAM no puede ser considerada un periférico de almacenamiento,
ya que su memoria es volátil y temporal.
En otras palabras, se encargan de guardar o salvar datos para que la CPU pueda hacer uso de
ellos una vez que han sido eliminados de la memoria principal, ya que ésta se borra cada vez
que se apaga la computadora. Pueden ser internos, como un disco duro, o extraíbles, como un
CD.
Los periféricos de almacenamiento más habituales son:
Disco duro
Grabadora y/o lector de CD
Grabadora y/o lector de DVD
Memoria Flash (usualmente las de las cámaras fotográficas).
Cintas magnéticas
Memoria portátil (pendrive)
Disquete
Periféricos de comunicación: Son los periféricos que se encargan de comunicarse con otras
máquinas o computadoras, ya sea para trabajar en conjunto, o para enviar y recibir
información. Su función es permitir o facilitar la interacción entre dos o más computadoras, o
entre una computadora y otro periférico externo a la computadora.

Los periféricos de comunicación más habituales son:

Fax-Módem.
Tarjeta de red.
Tarjeta Wireless tipo infrarrojo.
Tarjeta Bluetooth.
Controladores de puertos (serie, paralelo, infrarrojo, etc.)
USB
Otros conceptos y curiosidades

Algunos computadores más grandes se diferencian del modelo anterior, en un aspecto
importante, porque tienen varias CPU y unidades de control que trabajan al mismo tiempo.
Además, algunos computadores, usados principalmente para investigación, son muy diferentes
del modelo anterior, pero no tienen muchas aplicaciones comerciales.
En la actualidad, podemos tener la impresión de que los computadores están ejecutando varios
programas al mismo tiempo. Esto se conoce como multitarea, siendo más usado el segundo
término. En realidad, la CPU ejecuta instrucciones de un programa y después tras un breve
periodo de tiempo, cambian a un segundo programa y ejecuta algunas de sus instrucciones.
Esto crea la ilusión de que se están ejecutando varios programas simultáneamente, repartiendo
el tiempo de la CPU entre los programas. Esto es similar a la película que está formada por una
sucesión rápida de fotogramas. El sistema operativo es el programa que generalmente controla
el reparto del tiempo.
El sistema operativo sirve para decidir, por ejemplo, qué programas se ejecutan, y cuándo, y
qué fuentes (memoria o dispositivos E/S) se utilizan. El sistema operativo tiene otras funciones
que ofrecer a otros programas, como los códigos que sirven a los programadores, escribir
programas para una máquina sin necesidad de conocer los detalles internos de todos los
dispositivos electrónicos conectados.
En la actualidad se están empezando a incluir dentro del sistema operativo algunos programas
muy usados debido a que es una manera económica de distribuirlos. No es extraño que un
sistema operativo incluya navegadores de Internet, procesadores de texto, programas de
correo electrónico, interfaces de red, reproductores de películas y otros programas que antes
se tenían que conseguir e instalar separadamente.
SOFTWARE
Se denomina software (palabra de origen anglosajón, pronunciada "sóft-uer"), programa,
equipamiento lógico o soporte lógico a todos los componentes intangibles de una computadora,
es decir, al conjunto de programas y procedimientos necesarios para hacer posible la
realización de una tarea específica, en contraposición a los componentes físicos del sistema
(hardware). Esto incluye aplicaciones informáticas tales como un procesador de textos, que
permite al usuario realizar una tarea, y software de sistema como un sistema operativo, que
permite al resto de programas funcionar adecuadamente, facilitando la interacción con los
componentes físicos y el resto de aplicaciones.
Probablemente la definición más formal de software es la atribuida a la IEEE en su estándar
729: «la suma total de los programas de cómputo, procedimientos, reglas documentación y
datos asociados que forman parte de las operaciones de un sistema de cómputo». Bajo esta
definición, el concepto de software va más allá de los programas de cómputo en sus distintas
formas: código fuente, binario o ejecutable, además de su documentación: es decir, todo lo
intangible.
El término «software» fue usado por primera vez en este sentido por John W. Tukey en 1957.
En las ciencias de la computación y la ingeniería de software, el software es toda la información

procesada por los sistemas informáticos: programas y datos. El concepto de leer diferentes
secuencias de instrucciones de la memoria de un dispositivo para controlar cálculos fue
inventado por Charles Babbage como parte de su máquina diferencial. La teoría que forma la
base de la mayor parte del software moderno fue propuesta por vez primera por Alan Turing en
su ensayo de 1936, Los números computables, con una aplicación al problema de decisión.
TIPOLOGÍA DEL SOFTWARE

Si bien esta distinción es, en cierto modo, arbitraria, y, a veces, difusa y confusa, se puede
distinguir al software de la siguiente forma:
Software de sistema. Es la parte que permite funcionar al hardware. Su objetivo es aislar tanto
como sea posible al programador de aplicaciones de los detalles del computador particular que
se use, especialmente de las características físicas de la memoria, dispositivos de
comunicaciones, impresoras, pantallas, teclados, etcétera. Incluye entre otros:
Sistemas operativos
Controladores de dispositivo
Herramientas de diagnóstico
Servidores
Sistemas de ventanas
Utilidades
Software de programación. Que proporciona herramientas para ayudar al programador a
escribir programas informáticos y a usar diferentes lenguajes de programación de forma
práctica. Incluye entre otros:
Editores de texto
Compiladores
Intérpretes
Enlazadores
Depuradores
Software de aplicación. Que permite a los usuarios llevar a cabo una o varias tareas más
específicas, en cualquier campo de actividad susceptible de ser automatizado o asistido, con
especial énfasis en los negocios. Incluye entre otros:
Aplicaciones de automatización industrial
Software educativo
Software médico
Bases de datos
Videojuegos
Archivos de datos
LOS SISTEMAS OPERATIVOS.

Para que una maquina basada completamente en electrónica y un ser humano con miles de
años de evolución se entiendan no ha sido fácil la comunicación entre ambos. Desde sus
orígenes los primeros diseñadores y creadores de éstas se dieron cuenta que necesitaban algo
más que permitiera la fácil interpretación de las instrucciones así como de los resultados
obtenidos, para lo cuál crearon un programa básico que toda computadora debe cargar primero
en su memoria para poderse comunicar y comprender con un ser humano.
Así nació el Sistema Operativo, programa básico que se carga al momento de encender la
máquina y sirve de intérprete entre el frío lenguaje de la maquina electrónica y el complejo
idioma humano, el Sistema operativo es pues, el gobierno interno de la máquina.

LENGUAJES DE PROGRAMACIÓN
Los lenguajes utilizados para escribir programas de computadoras que puedan ser entendidos
por ellas se denominan lenguajes de programación. Los lenguajes de programación se
clasifican en tres grandes categorías: de maquinas, de bajo nivel y de alto nivel.
Lenguaje de maquina:
El lenguaje de maquina es aquel cuyas instrucciones son directamente entendibles por la
computadora y no necesitan traducción posterior para que el µP pueda comprender y ejecutar
el programa.
Las instrucciones en lenguaje maquina se expresan en términos de la unidad de memoria más
pequeña (bit) = digito binario 0 ó 1, en esencia una secuencia de bits que especifican la
operación y las celdas de memoria implicadas en una operación
Ejemplo de instrucciones en lenguaje de maquina: 0010, 0000, 1001, 1001, 10001, 1110.
Como se observa estas instrucciones son fáciles de leer por una computadora y difíciles para
un programador. Por esta razón se hace difícil escribir programas en código o lenguaje de
maquina. Y se requiere otro lenguaje para comunicarse con la computadora que se hace más
fácil de escribir y de leer por el programador. Para evitar la tediosa tarea de escribir programas
en este lenguaje se han diseñado otros programas de programación que facilitan la escritura y
posterior ejecución de los programas, estos son lenguajes de bajo y alto nivel.
Lenguaje de bajo nivel (ensambladores)

La programación en lenguaje de maquina es difícil, por ello se necesitan lenguajes que
permitan simplificar este proceso los lenguajes de bajo nivel han sido diseñados para ese fin.
Estos lenguajes dependen de la maquina o sea del conjunto de instrucciones especificas de la
computadora, por ejemplo el lenguaje ensamblador, en el cual las instrucciones se escriben en
códigos alfabéticos conocidos como nemotécnicos (abreviaturas de palabras inglesas o
españolas, ejemplo sumar en ingles
ADD = suma
SUB= resta
MPY = multiplicar
DIV=dividir
LDA= cargar acumulador
STO= almacenar
Las palabras nemotécnicas son mas fáciles de recordar que las secuencias de dígitos de 0 a 1.
Una instrucción típica en ensamblador puede ser
ADD X, Y, Z.
Esta instrucción significa que se deben sumar los números almacenados en las direcciones X,Y
y luego almacenar el resultado en la dirección Z, el lenguaje ensamblador traducirá la
instrucción a código de maquina, por ejemplo.
ADD = 1110
X=1001
Y=1010
Z=1011
La instrucción traducida será 1110 1001 1000 1011
Después que un programa ha sido escrito en lenguaje ensamblador se necesita un programa
llamado ensamblador, que lo traduzca a código de maquina.

Programa fuente Programa en

Ensamblador
en lenguaje lenguanje de
(Assembler)
Ensamblador maquina
Lenguaje de alto nivel.

Los lenguajes de programación de alto nivel (BASIC, PASCAL, FORTRAN, C, C++, COBOL)
son aquellos en los cuales las instrucciones o sentencias a la computadora se escriben con
palabras similares a los lenguajes humanos.
En general en lenguaje ingles como es el caso de C o C++, lo cual facilita la escritura y la
comprensión por parte del programador.
Características de los lenguajes de programación:

Transportabilidad: un programa escrito en un lenguaje de alto nivel se puede escribir con poca
o ninguna modificación en distintos tipos de computadora.
Independencia: Los lenguajes deben ser independientes de la máquina o sea una sentencia no
depende del diseño de hardware de una computadora en particular.
Los programas escritos en lenguaje de alto nivel no son entendibles directamente por la
maquina.
Necesitan ser traducidos a instrucciones en lenguaje de maquina que lo entienda la
computadora.
Los programas que realizan esta traducción se llaman programas compiladores.
Los programas escritos en lenguaje de alto nivel se llaman programas fuentes
El compilador traduce el programa fuente en un programa objeto, el cual se utiliza en la fase de
ejecución del programa.
Algunas computadoras o microcomputadoras utilizan unos programas similares llamados
programas interpretes que traducen los programas.
El proceso de traducción de un programa fuente se denomina interpretación o compilación,
según sea el programa.
Un intérprete traduce y ejecuta una traducción (sentencia) en código fuente cada vez. Los
programas interpretados generalmente se ejecutan mucho más lentamente que los programas
compilados; sin embargo los intérpretes son más fáciles de utilizar y la depuración (corrección)
de errores es mucho más cómoda.
Basic, Basica (Basic Avanced), GW-Basic, son interpretes y Quick Basic es un compilador.
Fortran, Pascal , C, son programas compiladores.
Los lenguajes de programación C, Turbo C, C++ , son programas orientados a objeto. Windows
fue desarrollado en C.
Visual Basic es un lenguaje orientado a eventos.
FORMAS DEL SOFTWARE

El software adopta varias formas en distintos momentos de su ciclo de vida:
Código fuente: escrito por programadores. Contiene el conjunto de instrucciones destinadas a
la computadora.

Código objeto: resultado del uso de un compilador sobre el código fuente. Consiste en una
traducción de éste último. El código objeto no es directamente inteligible por el ser humano,
pero tampoco es directamente entendible por la computadora. Se trata de una representación
intermedia del código fuente.
Código ejecutable: resultado de enlazar uno o varios fragmentos de código objeto. Constituye
un archivo binario con un formato tal que el sistema operativo es capaz de cargarlo en la
memoria de una computadora, y proceder a su ejecución.
Código o Programa Compilado Código o Programa Linkeado Código o Programa

fuente en lenguaje objeto en lenguaje ejecutable en lenguaje
de alto nivel de bajo nivel de maquina
EL PROCESO DE CREACIÓN DE SOFTWARE

El proceso de creación de software es materia de la ingeniería del software, una de las ramas
propias de la Ingeniería Informática. Es un proceso complejo que involucra diversas tareas de
gestión y desarrollo. Como resumen de las etapas para la creación de un software, se pueden
mencionar:
Análisis
Desarrollo
Construcción
Pruebas (unitarias e integradas)
Producción
PROGRAMACIÓN.
Se conoce como programación de computadoras a la implementación de un algoritmo en un
determinado lenguaje de programación, conformando un programa. Mientras que un algoritmo
se ejecuta en una máquina abstracta que no tiene limitaciones de memoria o tiempo, un
programa se ejecuta en una máquina real, que sí tiene esas limitaciones. El lenguaje de
programación puede ser de alto nivel o bajo nivel, en función del grado de abstracción.
Programas y algoritmos.
Un algoritmo es una secuencia no ambigua, finita y ordenada de instrucciones que han de
seguirse para resolver un problema. Un programa normalmente implementa (traduce a un
lenguaje de programación concreto) un algoritmo. Nótese que es la secuencia de instrucciones
en sí la que debe ser finita, no el número de pasos realizados como la ejecución de ellas.
Los programas suelen subdividirse en partes menores (módulos), de modo que la complejidad
algorítmica de cada una de las partes sea menor que la del programa completo, lo cual ayuda
al desarrollo del programa.
Según Niklaus Wirth un programa está formado por algoritmos y estructura de datos.
Se han propuesto diversas técnicas de programación, cuyo objetivo es mejorar tanto el proceso
de creación de software como su mantenimiento. Entre ellas se pueden mencionar las
programaciones lineal, estructurada, modular y orientada a objetos.
Compilación.
El programa escrito en un lenguaje de programación (comprensible por el ser humano, aunque
se suelen corresponder con lenguajes formales descritos por gramáticas independientes del

contexto) no es inmediatamente ejecutado en una computadora. La opción más común es

compilar el programa, aunque también puede ser ejecutado mediante un intérprete informático.
El código fuente del programa se debe someter a un proceso de transformación para
convertirse en lenguaje máquina, interpretable por el procesador. A este proceso se le llama
compilación.
Normalmente la creación de un programa ejecutable (un típico .exe para Microsoft Windows)
conlleva dos pasos. El primer paso se llama compilación (propiamente dicho) y traduce el
código fuente escrito en un lenguaje de programación almacenado en un archivo a código en
bajo nivel, (normalmente en código objeto no directamente al lenguaje máquina). El segundo
paso se llama enlazado (del inglés link o linker) se junta el código de bajo nivel generado de
todos los ficheros que se han mandado compilar y se añade el código de las funciones que hay
el las bibliotecas del compilador para que el ejecutable pueda comunicarse con el sistemas
operativo y traduce el código objeto a código máquina.
Estos dos pasos se pueden mandar hacer por separado, almacenando el resultado de la fase
de compilación en archivos objetos (un típico .obj para Microsoft Windows, .o para Unix), para
enlazarlos posteriormente, o crear directamente el ejecutable con lo que la fase de compilación
se almacena sólo temporalmente. Un programa podría tener partes escritas en varios lenguajes
(generalmente C, C++ y Asm), que se podrían compilar de forma independiente y enlazar
juntas para formar un único ejecutable.
Programación e ingeniería del software

Existe una tendencia a identificar el proceso de creación de un programa informático con la
programación, que es cierta cuando se trata de programas pequeños para uso personal, y que
dista de la realidad cuando se trata de grandes proyectos.
El proceso de creación de software desde el punto de vista de la Ingeniería tiene los siguientes
pasos:
Reconocer la necesidad de un programa para solucionar un problema ó identificar la posibilidad
de automatización de una tarea.
Recoger los requisitos del programa. Debe quedar claro qué es lo que debe hacer el programa
y para qué se necesita.
Realizar el análisis de los requisitos del programa. Debe quedar claro cómo debe realizar el
programa las cosas que debe hacer. Las pruebas que comprueben la validez del programa se
pueden especificar en esta fase.
Diseñar la arquitectura del programa. Se debe descomponer el programa en partes de
complejidad abordable.
Implementar el programa. Consiste en realizar un diseño detallado, especificando
completamente todo el funcionamiento del programa, tras lo cual la codificación debería
resultar inmediata.
Implantar (instalar) el programa. Consiste en poner el programa en funcionamiento junto con
los componentes que pueda necesitar (bases de datos, redes de comunicaciones, etc.)
La Ingeniería del Software se centra en los pasos de planificación y diseño del programa,
mientras que antiguamente (programación artesanal) la realización de un programa consistía
únicamente en escribir el código.
Objetivos de la programación
La programación de ordenadores debe perseguir tres objetivos fundamentales:

Corrección: un programa es correcto si hace lo que debe hacer. Para determinar si un

programa hace lo que debe es muy importante especificar claramente qué debe hacer el
programa antes de desarrollarlo y una vez acabado compararlo con lo que realmente hace.
Claridad: es muy importante que el programa sea lo más claro y legible posible para mejorar el
mantenimiento del software. Cuando se acaba de escribir el código del programa, se deben
buscar errores y corregirlos. Más concretamente, cuando el programa está concluido, es
necesario hacerle ampliaciones o modificaciones, según la demanda de los usuarios, esta labor
puede ser llevada acabo por el mismo programador que implementó el programa o por otros.
Eficiencia: debe consumir la menor cantidad de recursos posible. Normalmente al hablar de
eficiencia se suele hacer referencia al consumo de tiempo y/o memoria.
La eficiencia y la claridad de un programa pueden ser objetivos contrapuestos: se puede
conseguir mayor claridad sacrificando parte de la eficiencia o viceversa. Pero hay que tener en
cuenta que el tiempo del programador es caro, y que hoy en día el precio de los ordenadores
es razonable y cada vez son más baratos.
CONCEPTO DE "PROGRAMA"
Un programa –en sentido informático– está constituido por un conjunto de instrucciones que se
ejecutan –ordinariamente– de modo secuencial, es decir, cada una a continuación de la
anterior. Recientemente, con objeto de disminuir los tiempos de ejecución de programas
críticos por su tamaño o complejidad, se está haciendo un gran esfuerzo en desarrollar
programas paralelos, esto es, programas que se pueden ejecutar simultáneamente en varios
procesadores. La programación paralela es mucho más complicada que la secuencial y no se
hará referencia a ella en este curso. Análogamente a los datos que maneja, las instrucciones
que un procesador digital es capaz de entender están constituidas por conjuntos de unos y
ceros. A esto se llama lenguaje de máquina o binario, y es muy difícil de manejar. Por ello,
desde casi los primeros años de los ordenadores, se comenzaron a desarrollar los llamados
lenguajes de alto nivel (tales como el Fortran, el Cobol, etc.), que están mucho más cerca del
lenguaje natural. Estos lenguajes están basados en el uso de identificadores, tanto para los
datos como para las componentes elementales del programa, que en algunos lenguajes se
llaman rutinas o procedimientos, y que en C se denominan funciones. Además, cada lenguaje
dispone de una sintaxis o conjunto de reglas con las que se indica de modo inequívoco las
operaciones que se quiere realizar. Los lenguajes de alto nivel son más o menos
comprensibles para el usuario, pero no para el procesador. Para que éste pueda ejecutarlos es
necesario traducirlos a su propio lenguaje de máquina. Esta es una tarea que realiza un
programa especial llamado compilador, que traduce el programa a lenguaje de máquina. Esta
tarea se suele descomponer en dos etapas, que se pueden realizar juntas o por separado. El
programa de alto nivel se suele almacenar en uno o más ficheros llamados ficheros fuente, que
en casi todos los sistemas operativos se caracterizan por una terminación –también llamada
extensión– especial. Así, todos los ficheros fuente de C deben terminar por (.c o .cpp);
ejemplos de nombres de estos ficheros son calculos.c, derivada.c, etc. La primera tarea del
compilador es realizar una traducción directa del programa a un lenguaje más próximo al del
computador (llamado ensamblador), produciendo un fichero objeto con el mismo nombre que el
fichero original, pero con la extensión (.obj u simplemente .o). En una segunda etapa se realiza
el proceso de montaje (linkage) del programa, consistente en producir un programa ejecutable
en lenguaje de máquina, en el que están ya incorporados todos los otros módulos que aporta el
sistema sin intervención explícita del programador (funciones de librería, recursos del sistema
operativo, etc.). En un PC con sistema operativo Windows el programa ejecutable se guarda en
un fichero con extensión (*.exe). Este fichero es cargado por el sistema operativo en la
memoria RAM cuando el programa va a ser ejecutado.

Una de las ventajas más importantes de los lenguajes de alto nivel es la portabilidad de los
ficheros fuente resultantes. Quiere esto decir que un programa desarrollado en un PC podrá
ser ejecutado en un Macintosh o en una máquina UNIX, con mínimas modificaciones y una
simple recopilación. El lenguaje C, originalmente desarrollado por D. Ritchie en los laboratorios
Bell de la AT&T, fue posteriormente estandarizado por un comité del ANSI (American National
Standard Institute) con objeto de garantizar su portabilidad entre distintos computadores, dando
lugar al ANSI C, que es la variante que actualmente se utiliza casi universalmente.
CONCEPTO DE “FUNCIÓN”
Las aplicaciones informáticas que habitualmente se utilizan, incluso a nivel de informática
personal, suelen contener decenas y aún cientos de miles de líneas de código fuente. A
medida que los programas se van desarrollando y aumentan de tamaño, se convertirían
rápidamente en sistemas poco manejables si no fuera por la modularización, que es el proceso
consistente en dividir un programa muy grande en una serie de módulos mucho más pequeños
y manejables. A estos módulos se les suele denominar de distintas formas (subprogramas,
subrutinas, procedimientos, funciones, etc.) según los distintos lenguajes. El lenguaje C hace
uso del concepto de función (function). Sea cual sea la nomenclatura, la idea es sin embargo
siempre la misma: dividir un programa grande en un conjunto de subprogramas o funciones
más pequeñas que son llamadas por el programa principal; éstas a su vez llaman a otras
funciones más específicas y así sucesivamente.
La división de un programa en unidades más pequeñas o funciones presenta –entre otras– las
ventajas siguientes:
Modularización. Cada función tiene una misión muy concreta, de modo que nunca tiene un
número de líneas excesivo y siempre se mantiene dentro de un tamaño manejable. Además,
una misma función (por ejemplo, un producto de matrices, una resolución de un sistema de
ecuaciones lineales) puede ser llamada muchas veces en un mismo programa, e incluso puede
ser reutilizada por otros programas. Cada función puede ser desarrollada y comprobada por
separado.
Ahorro de memoria y tiempo de desarrollo. En la medida en que una misma función es
utilizada muchas veces, el número total de líneas de código del programa disminuye, y también
lo hace la probabilidad de introducir errores en el programa.
Independencia de datos y ocultamiento de información. Una de las fuentes más comunes
de errores en los programas de computador son los efectos colaterales o perturbaciones que
se pueden producir entre distintas partes del programa. Es muy frecuente que al hacer una
modificación para añadir una funcionalidad o corregir un error, se introduzcan nuevos errores
en partes del programa que antes funcionaban correctamente. Una función es capaz de
mantener una gran independencia con el resto del programa, manteniendo sus propios datos y
definiendo muy claramente la interfaz o comunicación con la función que la ha llamado y con
las funciones a las que llama, y no teniendo ninguna posibilidad de acceso a la información que
no le compete. Las funciones de C están implementadas con un particular cuidado y riqueza,
constituyendo uno de los aspectos más potentes del lenguaje. Es muy importante entender
bien su funcionamiento y sus posibilidades.
Nombre, valor de retorno y argumentos de una función

Una función de C es una porción de código o programa que realiza una determinada tarea. Una
función está asociada con un identificador o nombre, que se utiliza para referirse a ella desde el
resto del programa. En toda función utilizada en C hay que distinguir entre su definición, su
declaración y su llamada. Para explicar estos conceptos hay que introducir los conceptos de
valor de retorno y de argumentos.

Quizás lo mejor sea empezar por el concepto más próximo al usuario, que es el concepto de
llamada. Las funciones en C se llaman incluyendo su nombre, seguido de los argumentos, en
una sentencia del programa principal o de otra función de rango superior. Los argumentos son
datos que se envían a la función incluyéndolos entre paréntesis a continuación del nombre,
separados por comas. Por ejemplo, supóngase una función llamada power que calcula x
elevado a y. Una forma de llamar a esta función es escribir la siguiente sentencia (las
sentencias de C terminan con punto y coma):
power(x,y);
En este ejemplo power es el nombre de la función, y x e y son los argumentos, que en este
caso constituyen los datos necesarios para calcular el resultado deseado. ¿Qué pasa con el
resultado? ¿Dónde aparece? Pues en el ejemplo anterior el resultado es el valor de retorno de
la función, que está disponible pero no se utiliza. En efecto, el resultado de la llamada a power
está disponible, pues aparece sustituyendo al nombre de la función en el mismo lugar donde se
ha hecho la llamada; en el ejemplo anterior, el resultado aparece, pero no se hace nada con él.
A este mecanismo de sustitución de la llamada por el resultado es a lo que se llama valor de
retorno. Otra forma de llamar a esta función utilizando el resultado podría ser la siguiente:
distancia = power(x+3, y)*escala;
En este caso el primer argumento (x+3) es elevado al segundo argumento y, el resultado de la
potencia –el valor de retorno– es multiplicado por escala, y este nuevo resultado se almacena
en la posición de memoria asociada con el identificador distancia. Este ejemplo resulta típico de
lo que es una instrucción o sentencia que incluye una llamada a una función en el lenguaje C.
Para poder llamar a una función es necesario que en algún otro lado, en el mismo o en algún
otro fichero fuente, aparezca la definición de dicha función, que en el ejemplo anterior es la
función power. La definición de una función es ni más ni menos que el conjunto de sentencias o
instrucciones necesarias para que la función pueda realizar su tarea cuando sea llamada. En
otras palabras, la definición es el código correspondiente a la función. Además del código, la
definición de la función incluye la definición del tipo del valor de retorno y de cada uno de los
argumentos. A continuación se presenta un ejemplo –incompleto– de cómo podría ser la
definición de la función power utilizada en el ejemplo anterior.
double power(double base, double exponente)
{
double resultado;
...
resultado = ... ;
return resultado;
}
La primera línea de la definición es particularmente importante. La primera palabra double
indica el tipo del valor de retorno. Esto quiere decir que el resultado de la función será un
número de punto flotante con unas 16 cifras de precisión (así es el tipo double, como se verá
más adelante). Después viene el nombre de la función seguido de –entre paréntesis– la
definición de los argumentos y de sus tipos respectivos. En este caso hay dos argumentos,
base y exponente, que son ambos de tipo double. A continuación se abren las llaves que
contienen el código de la función. La primera sentencia declara la variable resultado, que es
también de tipo double. Después vendrían las sentencias necesarias para calcular resultado
como base elevado a exponente. Finalmente, con la sentencia return se devuelve resultado al
programa o función que ha llamado a power.
Conviene notar que las variables base y exponente han sido declaradas en la cabecera –
primera línea– de la definición, y por tanto ya no hace falta declararlas después, como se ha

hecho con resultado. Cuando la función es llamada, las variables base y exponente reciben
sendas copias de los valores del primer y segundo argumento que siguen al nombre de la
función en la llamada.
Una función debe ser también declarada antes de ser llamada. Además de la llamada y la
definición, está también la declaración de la función. Ya se verá más adelante dónde se puede
realizar esta declaración. La declaración de una función se puede realizar por medio de la
primera línea de la definición, de la que pueden suprimirse los nombres de los argumentos,
pero no sus tipos; al final debe incluirse el punto y coma (;). Por ejemplo, la función power se
puede declarar en otra función que la va a llamar incluyendo la línea siguiente:
double power(double, double);
La declaración de una función permite que el compilador chequee el número y tipo de los
argumentos, así como el tipo del valor de retorno. La declaración de la función se conoce
también con el nombre de prototipo de la función.
La función principal o función main()

Todo programa C, desde el más pequeño hasta el más complejo, tiene un programa principal
que es con el que se comienza la ejecución del programa. Este programa principal es también
una función, pero una función que está por encima de todas las demás. Esta función se llama
main() y tiene la forma siguiente (la palabra void es opcional en este caso):
void main(void)
{
sentencia_1
sentencia_2
...
}
Las llaves {...} constituyen el modo utilizado por el lenguaje C para agrupar varias sentencias
de modo que se comporten como una sentencia única (sentencia compuesta o bloque). Todo el
cuerpo de la función debe ir comprendido entre las llaves de apertura y cierre.
Palabras claves del C

En C, como en cualquier otro lenguaje, existen una serie de palabras clave (keywords) que el
usuario no puede utilizar como identificadores (nombres de variables y/o de funciones). Estas
palabras sirven para indicar al computador que realice una tarea muy determinada (desde
evaluar una comparación, hasta definir el tipo de una variable) y tienen un especial significado
para el compilador. El C es un lenguaje muy conciso, con muchas menos palabras clave que
otros lenguajes. A continuación se presenta la lista de las 32 palabras clave del ANSI C, para
las que más adelante se dará detalle de su significado (algunos compiladores añaden otras
palabras clave, propias de cada uno de ellos. Es importante evitarlas como identificadores):
Auto double int struct
Break else long switch
Case enum register typedef
Char extern return union
Const float short unsigned
Continue for signed void
Default goto sizeof volatile
Do if static while

ELEMENTOS
Comentarios
Los comentarios son textos que no son procesados por el compilador. Sirven como información
al programador. Para que un texto sea comentario debe estar entre los símbolos /* (marca el
comienzo) y */ (marca el final de comentario).
Identificadores
Se usan para referenciar las variables, las funciones, las etiquetas y otros objetos definidos por
el usuario. La longitud del identificador puede variar entre uno o varios caracteres (se
recomienda no más de 31.
El primer carácter debe ser una letra o un símbolo subrayado y los caracteres siguientes
pueden ser letras, números o símbolos de subrayado. Las minúsculas y las mayúsculas se
tratan como distintas.
Un identificador no puede ser igual a una palabra clave de C y no debe tener el mismo nombre
que una función ya escrita o que se encuentre en la biblioteca de C.
Variables
Una variable es una posición de memoria con nombre que se usa para mantener un valor que
puede ser modificado en el programa. Todas las variables deben ser declaradas antes de
poder usarlas.
Constantes
Las variables pueden cambiar de valor a lo largo de la ejecución de un programa, o bien en
ejecuciones distintas de un mismo programa. Además de variables, un programa utiliza
también constantes, es decir, valores que siempre son los mismos. Un ejemplo típico es el
número pi que vale 3.141592654. Este valor, con más o menos cifras significativas, puede
aparecer muchas veces en las sentencias de un programa. En C existen distintos tipos de
constantes:
Constantes numéricas. Son valores numéricos, enteros o de punto flotante. Se permiten
también constantes octales (números enteros en base 8) y hexadecimales (base 16).
Constantes carácter. Cualquier carácter individual encerrado entre apóstrofos (tal como 'a', 'Y',
')', '+', etc.) es considerado por C como una constante carácter.
Cadenas de caracteres. Un conjunto de caracteres alfanuméricos encerrados entre comillas es
también un tipo de constante del lenguaje C, como por ejemplo: "espacio", "Esto es una cadena
de caracteres", etc.
Una variable puede ser fijada a una constante con la sintaxis const tipo identificador = valor
(por ejemplo const int a=10).
Operadores
Los operadores son palabras o símbolos que hacen que un programa actúe sobre las
variables. En C existen cinco tipos de operadores:

Aritméticos:
+ Suma
- Resta
* Producto
/ Cociente de una división
% Resto de una división
Lógico:
! Not (inversor lógico)
&& And (Y lógico)
|| Or (O lógico)
Relacionales:
= = Igual a
!= No igual a
> Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que
De asignación:
Operador Sentencia abreviada Sentencia completa
= = =
++ m++ m=m+1
-- m-- m=m-1
+= m+=n m=m+n
-= m-=n m=m-n
*= m*=n m=m*n
/= m/=n m=m/n
%= m%=n m=m%n
De dirección:
* Operador de contenido de apuntado u operador de in dirección
& Operador de dirección
Sentencias
Una sentencia es una expresión en C donde se esperan unas consecuencias, normalmente
son asignaciones, operaciones, llamadas a funciones, etc.

TIPOS
Cuando en C se dice que un objeto es de un tipo, se quiere decir que ese objeto pertenece a
un conjunto específico de valores con los cuales se pueden realizar un conjunto de
operaciones también determinadas.
Existen cinco tipos básicos: carácter, entero, coma flotante, coma flotante de doble precisión y
void.
Los demás tipos se basan en alguno de estos tipos básicos.
La siguiente tabla muestra todas las combinaciones que se ajustan al estándar ANSI junto con
sus rangos mínimos y longitudes aproximadas en bits.
Tipo
Tamaño en 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

UNIDADES DE MEDIDA EMPLEADAS EN INFORMÁTICA
Los bytes, Kilobytes, Megabytes

En informática, la unidad básica de información es el byte. En la práctica, podemos pensar que
un byte es el equivalente a una letra. Si un cierto texto está formado por 2000 letras, podemos
esperar que ocupe unos 2000 bytes de espacio en nuestro disco. Eso sí, suele ocurrir que
realmente un texto de 2000 letras que se guarde en el ordenador ocupe más de 2000 bytes,
porque se suele incluir información adicional sobre los tipos de letra que se han utilizado,
cursivas, negritas, márgenes y formato de página, etc. Un byte se queda corto a la hora de
manejar textos o datos algo más largos, con lo que se recurre a un múltiplo suyo, el kilobyte,
que se suele abreviar Kb o K. En teoría, el prefijo kilo querría decir “mil”, luego un kilobyte
debería ser 1000 bytes, pero en los ordenadores conviene buscar por comodidad una potencia
de 2 (pronto veremos por qué), por lo que se usa 210 =1024. Así, la equivalencia exacta es 1 K
= 1024 bytes. Los K eran unidades típicas para medir la memoria de ordenadores: 640 K ha
sido mucho tiempo la memoria habitual en los IBM PC y similares. Por otra parte, una página
mecanografiada suele ocupar entre 2 K (cerca de 2000 letras) y 4 K. Cuando se manejan datos
realmente extensos, se pasa a otro múltiplo, el megabyte o Mb, que es 1000 K (en realidad
1024 K) o algo más de un millón de bytes. Por ejemplo, en un diskette “normal” caben 1.44 Mb,
y en un Compact Disc para ordenador (CD-Rom) se pueden almacenar hasta 700 Mb. La
memoria principal (RAM) de un ordenador actual suele andar por encima de los 512 Mb, y un
disco duro actual puede tener una capacidad superior a los 80.000 Mb. Para estas unidades de
gran capacidad, su tamaño no se suele medir en megabytes, sino en el múltiplo siguiente: en
gigabytes, con la correspondencia 1 Gb = 1024 Mb. Así, son cada vez más frecuentes los
discos duros con una capacidad de 120, 200 o más gigabytes. Y todavía hay unidades
mayores, pero que aún se utilizan muy poco. Por ejemplo, un terabyte son 1024 gigabytes.
Todo esto se puede resumir así:
Byte desde 0 a 255 (para guardar 1 letra)
Kilobyte (K o Kb) 1024 bytes
Megabyte (Mb) 1024 Kb
Gigabyte (Gb) 1024 Mb
Terabyte (Tb) 1024 Gb
Pero por debajo de los bytes también hay unidades más pequeñas...
Los bits
Dentro del ordenador, la información se debe almacenar realmente de alguna forma que a él le
resulte "cómoda" de manejar. Como la memoria del ordenador se basa en componentes
electrónicos, la unidad básica de información será que una posición de memoria esté usada o
no (totalmente llena o totalmente vacía), lo que se representa como un 1 o un 0. Esta unidad
recibe el nombre de bit. Un bit es demasiado pequeño para un uso normal (recordemos: sólo
puede tener dos valores: 0 ó 1), por lo que se usa un conjunto de ellos, 8 bits, que forman un
byte. Las matemáticas elementales (combinatoria) nos dicen que si agrupamos los bits de 8 en
8, tenemos 256 posibilidades distintas.
00000000
00000001
00000010
00000011
00000100
.........
……..
11111110
11111111

Por tanto, si en vez de tomar los bits de 1 en 1 (que resulta cómodo para el ordenador, pero no
para nosotros) los utilizamos en grupos de 8 (lo que se conoce como un byte), nos
encontramos con 256 posibilidades distintas, que ya son más que suficientes para almacenar
una letra, o un signo de puntuación, o una cifra numérica o algún otro símbolo. Por ejemplo, se
podría decir que cada vez que encontremos la secuencia 00000010 la interpretaremos como
una letra A, y la combinación 00000011 como una letra B, y así sucesivamente. También existe
una correspondencia entre cada grupo de bits y un número del 0 al 255: si usamos el sistema
binario de numeración (que aprenderemos dentro de muy poco), en vez del sistema decimal,
tenemos que:
0000 0000 (binario) = 0 (decimal)
...
En la práctica, existe un código estándar, el código ASCII (American Standard Code for
Information Interchange, código estándar americano para intercambio de información), que
relaciona cada letra, número o símbolo con una cifra del 0 al 255 (realmente, con una
secuencia de 8 bits): la "a" es el número 97, la "b" el 98, la "A" el 65, la "B", el 32, el "0" el 48, el
"1" el 49, etc. Así se tiene una forma muy cómoda de almacenar la información en
ordenadores, ya que cada letra ocupará exactamente un byte (8 bits: 8 posiciones elementales
de memoria). Aun así, hay un inconveniente con el código ASCII: sólo los primeros 127
números son estándar. Eso quiere decir que si escribimos un texto en un ordenador y lo
llevamos a otro, las letras básicas (A a la Z, 0 al 9 y algunos símbolos) no cambiarán, pero las
letras internacionales (como la Ñ o las vocales con acentos) puede que no aparezcan
correctamente, porque se les asignan números que no son estándar para todos los
ordenadores.
Nota: Eso de que realmente el ordenador trabaja con ceros y unos, por lo que le resulta más
fácil manejar los números que son potencia de 2 que los números que no lo son, es lo que
explica que el prefijo kilo no quiera decir “exactamente mil”, sino que se usa la potencia de 2
más cercana: 210 =1024. Por eso, la equivalencia exacta es 1 K = 1024 bytes.
SISTEMAS DE NUMERACIÓN
Sistema binario
Nosotros normalmente utilizamos el sistema decimal de numeración: todos los números se
expresan a partir de potencias de 10, pero normalmente lo hacemos sin pensar. Por ejemplo, el
número 3254 se podría desglosar como:
3254 = 3x1000 + 2x100 + 5x10 + 4x1
Aunque realmente nosotros lo hacemos automáticamente: no nos paramos a pensar este tipo
de cosas cuando sumamos o multiplicamos dos números.
Para los ordenadores no es cómodo contar hasta 10. Como partimos de “casillas de memoria”
que están completamente vacías (0) o completamente llenas (1), sólo les es realmente cómodo
contar con 2 cifras: 0 y 1. Por eso, dentro del ordenador cualquier número se deberá almacenar
como ceros y unos, y entonces los números se deberán desglosar en potencias de 2 (el
llamado “sistema binario”):
13 = 1x8 + 1x4 + 0x2 + 1x1
De modo que el número decimal 13 se escribirá en binario como 1101.

En general, convertir un número binario al sistema decimal es fácil: lo expresamos como suma
de potencias de 2 y sumamos:
0110 1101 (binario) = 0x27 + 1x26 + 1x25 + 0x24 + 1x23 + 1x22 + 0x21 + 1x20
0110 1101 (binario) = 0x128 + 1x64 + 1x32 + 0x16 + 1x8 + 1x4 + 0x2 + 1x1
Convertir un número de decimal a binario resulta algo menos intuitivo. Una forma sencilla es ir
dividiendo entre las potencias de 2, y tomar todos los cocientes de las divisiones:
109 / 128 = 0 (resto: 109)
109 / 64 = 1 (resto: 45)
45 / 32 = 1 (resto: 13)
13 / 16 = 0 (resto: 13)
13 / 8 = 1 (resto: 5)
5 / 4 = 1 (resto: 1)
1 / 2 = 0 (resto: 1)
1 / 1 = 1 (se terminó).
Si “juntamos” los cocientes que hemos obtenido, aparece el número binario que buscábamos:
109 decimal = 0110 1101 binario
Otra forma sencilla de convertir de decimal a binario es dividir consecutivamente entre 2 y
tomar los restos que hemos obtenido, pero en orden inverso:
109 / 2 = 54, resto 1
54 / 2 = 27, resto 0
27 / 2 = 13, resto 1
13 /2 = 6, resto 1
6 / 2 = 3, resto 0
3 / 2 = 1, resto 1
1 / 2 = 0, resto 1
Si leemos esos restos de abajo hacia arriba, obtenemos el número binario: 1101101 (7 cifras, si
queremos completarlo a 8 cifras rellenamos con ceros por la izquierda: 01101101).
¿Y se pueden hacer operaciones con números binarios? Sí, casi igual que en decimal:
0·0 = 0 0+0=0
0·1 = 0 0+1=1
1·0 = 0 1+0=1
1·1 = 1 1+1 = 10 (en decimal: 2)
Sistema Hexadecimal
Una forma más cómoda de trabajar es agrupando de 4 en 4 los bits. Este sistema de
numeración trabajará en base 16 (24 =16), y es lo que se conoce como sistema hexadecimal.
Pero hay una dificultad: estamos acostumbrados al sistema decimal, con números del 0 al 9, de
modo que no tenemos cifras de un solo dígito para los números 10, 11, 12, 13, 14 y 15, que
utilizaremos en el sistema hexadecimal. Para representar estas cifras usaremos las letras de la
A a la F, así:
0 (decimal) = 0 (hexadecimal) 6 (decimal) = 6 (hexadecimal)
4 (decimal) = 4 (hexadecimal) 10 (decimal) = A (hexadecimal)
5 (decimal) = 5 (hexadecimal) 11 (decimal) = B (hexadecimal)

12 (decimal) = C (hexadecimal) 14 (decimal) = E (hexadecimal)

13 (decimal) = D (hexadecimal) 15 (decimal) = F (hexadecimal)
Con estas consideraciones, expresar números en el sistema hexadecimal ya no es difícil:
254 (decimal) a hexadecimal, seria:
254 / 16 = 15 (resto: 14)
14 / 1 = 14
De modo que
254(decimal) = 15x16 + 14x1
254(decimal) = 15x161 + 14x160
254 (decimal) = FE (hexadecimal)
Vamos a repetirlo para un convertir de decimal a hexadecimal un número más grande:
54331 (decimal) a hexadecimal, seria:
54331 / 4096 = 13 (resto: 1083)
1083 / 256 = 4 (resto: 59)
59 / 16 = 3 (resto: 11)
11 / 1 = 11
De modo que
54331 = 13x4096 + 4x256 + 3x16 + 11x1
54331 = 13x163 + 4x162 + 3x161 + 11x160
54331 (decimal) = D43B (hexadecimal)
Ahora vamos a dar el paso inverso: convertir de hexadecimal a decimal, por ejemplo el número
A2B5
A2B5 (hexadecimal) = 10x163 + 2x162 + 11x161 + 5x160
A2B5 (hexadecimal) = 41653
El paso de hexadecimal a binario también es (relativamente) rápido, porque cada dígito
hexadecimal equivale a una secuencia de 4 bits:
0 (hexadecimal) = 0 (decimal) = 0000 (binario)
A (hexadecimal) = 10 (decimal) = 1010 (binario)
B (hexadecimal) = 11 (decimal) = 1011 (binario)
C (hexadecimal) = 12 (decimal) = 1100 (binario)
D (hexadecimal) = 13 (decimal) = 1101 (binario)
E (hexadecimal) = 14 (decimal) = 1110 (binario)
F (hexadecimal) = 15 (decimal) = 1111 (binario)
De modo que A2B5 (hexadecimal) = 1010 0010 1011 0101 (binario) y de igual modo, de binario
a hexadecimal es dividir en grupos de 4 bits y hallar el valor de cada uno de ellos:
0110 0101 0010 0100 1010 1010 0111 = 6524AA7

DIAGRAMAS DE FLUJO
Un algoritmo es un conjunto ordenado y finito de operaciones que permite hallar la solución de
un problema. Es evidente, a partir de la definición, que un algoritmo es independiente del
lenguaje de programación que se utilice para realizar la solución.
Por eso es muy conveniente separar la realización de un programa en dos fases: elaboración
del algoritmo que soluciona el problema, y traducción del algoritmo al lenguaje de
programación deseado (en nuestro caso el C).
De las diferentes técnicas que existen para la representación de un algoritmo, la más utilizada
es la de los diagramas de flujo. En ellos se utilizan símbolos (cajas) unidos por flechas (líneas
de flujo) que indican las operaciones a realizar y el orden o dirección de flujo del programa
respectivamente. Como se puede comprobar es una forma gráfica e intuitiva de ver la
estructura global de un algoritmo.
Algunos de los símbolos utilizados en los diagramas de flujo son los siguientes:
Inicio
Fin
Programación Estructurada
La programación estructurada se basa en la utilización de un reducido número de estructuras
que permitan hacer que un programa sea suficientemente legible, reduciendo
considerablemente el número de errores, y facilitando enormemente la detección y solución de
éstos.
La característica fundamental de la programación estructurada consiste en que todas las
estructuras tienen un único punto de entrada y un único punto de salida. Esto permite
descomponer fácilmente un problema en subproblemas, reduciendo la complejidad y facilitando
la programación.

Las estructuras que incorpora el C basadas en la programación estructurada son:

Secuenciales
Selectivas
Repetitivas
Se debe evitar el uso de cualquier otra estructura que no sea una de las anteriores, ya que
conduce a código no estructurado. Contrariamente a lo que pudiera parecer en un primer
momento, esto no supone ninguna limitación a la hora de realizar un programa, ya que se
puede demostrar que cualquier programa se puede realizar utilizando únicamente estas
estructuras. En concreto, no es recomendado la utilización de las sentencias goto (que realiza
un salto incondicional) y continue (que fuerza una nueva iteración dentro de una estructura
repetitiva), y sólo se permite la utilización de la sentencia break (que fuerza la salida de una
estructura selectiva o repetitiva) en el ámbito de la sentencia selectiva múltiple. Estas
sentencias de explicaran con más detalles luego de comprender las estructuras selectivas
repetitivas.
A partir de ahora se explicara la simbología en el diagrama de flujo, la instrucción en C y un

ejemplo práctico de cada una de las sentencias básicas que conforman el lenguaje de
programación C.
COMANDO #INCLUDE
Cuando en un archivo .c se encuentra una línea con un #include seguido de un nombre de
archivo, el preprocesador la sustituye por el contenido de ese archivo. La sintaxis de este
comando es la siguiente:
#include "nombre_del_archivo"
#include <nombre_del_archivo>
La diferencia entre la primera forma (con comillas "...") y la segunda forma (con los símbolos
<...>) estriba en el directorio de búsqueda de dichos archivos. En la forma con comillas se
busca el archivo en el directorio actual y posteriormente en el directorio estándar de librerías
(definido normalmente con una variable de entorno del MS-DOS llamada INCLUDE, en el caso
de los compiladores de Microsoft). En la forma que utiliza los símbolos <...> se busca
directamente en el directorio estándar de librerías. En la práctica, los archivos del sistema
(stdio.h, math.h, etc.) se incluyen con la segunda forma, mientras que los archivos hechos por
el propio programador se incluyen con la primera.
Este comando del preprocesador se utiliza normalmente para incluir archivos con los prototipos
(declaraciones) de las funciones de librería, o con módulos de programación y prototipos de las
funciones del propio usuario. Estos archivos suelen tener la extensión *.h, aunque puede
incluirse cualquier tipo de archivo de texto.

ESTRUCTURAS SECUENCIALES
FUNCIÓN PRINTF()
“Aquí se escribe el texto que saldrá por pantalla”

O
La función printf() imprime en la unidad de salida (el monitor, por defecto), el texto, y las
constantes y variables que se indiquen. La forma general de esta función se puede estudiar
viendo su prototipo:
int printf("cadena_de_caracteres", tipo arg1, tipo arg2, ...)
Explicación: La función printf() imprime el texto contenido escrito en cadena_de_caracteres
junto con el valor de los otros argumentos, de acuerdo con los formatos incluidos en
cadena_de_caracteres. Los puntos suspensivos (...) indican que puede haber un número
variable de argumentos entre un printf() y otro del mismo programa. Cada formato comienza
con el carácter (%) y termina con un carácter de conversión.
Considérese el siguiente ejemplo:
Programa:
int i=5;
double tiempo=48;
float masa=3.78;
printf("Resultado numero %d. En el instante %lf la masa vale %f\n", i,
tiempo, masa);
Resultado:
Resultado numero 5. En el instante 48.000000 la masa vale 3.780000
En el que se imprimen 3 variables (i, tiempo y masa) con los formatos (%d, %lf y %f),
correspondientes a los tipos (int, double y float), respectivamente. La cadena_de_caracteres
se imprime con el valor de cada variable intercalado en el lugar del formato correspondiente.
Los caracteres de conversión utilizados en la función printf() son:
Carácter de conversión Tipo de argumento
d, i int decimal
u int unsigned
c char
f float notación decimal
p puntero (void *)
o octal unsigned
x,X hexadecimal unsigned
s cadena de char
e,g float notación científica
Lo importante es considerar que debe haber correspondencia uno a uno (el 1º con el 1º, el 2º
con el 2º, etc.) entre los formatos que aparecen en la cadena_de_caracteres y los otros
argumentos (constantes, variables o expresiones).

Entre el carácter % y el carácter de conversión puede haber uno o varios de los elementos que
a continuación se indican:
• Un número entero positivo, que indica la anchura mínima del campo en caracteres.
Programa:
int entero1=1523;
int entero2=78;
printf("%5i\n",entero1); /*reserva cinco lugares mínimos para la
impresión en pantalla de la variable i*/
printf("%2i\n",entero1); /*reserva dos lugares mínimos para la
impresión en pantalla de la variable i*/
printf("\n\n");
printf("%5i\n%5i\n",entero1,entero2);
printf("\n\n");
printf("%i\n%i\n",entero1,entero2);
Resultado:
1523
1523
1523
78
1523
78
• Un signo (-), que indica alineamiento por la izquierda (el defecto es por la derecha).
Programa:
int entero1=1523;
int entero2=78;
printf("%5i\n%5i\n",entero1,entero2);
printf("\n\n");
printf("%-5i\n%-5i\n",entero1,entero2);
Resultado:
1523
78
1523
78
• Un punto (.), que separa la anchura de la precisión, el cual será un número entero
positivo indicando el número máximo de caracteres a imprimir en un string, el número
de decimales de un float o double, o las cifras mínimas de un int o long.
Programa:
float entero1=1523.2345;
printf("%5.2f\n%5.4f\n\n",entero1,entero1);
Resultado:
1523.23
1523.2345
• Un cualificador: una (h) para short o una (l) para long y double.
A continuación se incluyen algunos ejemplos de uso de la función printf().

El primer ejemplo contiene sólo texto, por lo que basta con considerar la
cadena_de_caracteres:
Programa:
printf("Con cien cañones por banda,\nviento en popa a toda vela,\n");
Resultado:
Con cien cañones por banda,
viento en popa a toda vela,
No es posible partir cadena_de_caracteres en varias líneas con caracteres intro (\n), por lo que
en este ejemplo podría haber problemas para añadir más estrofas. Una forma alternativa, muy
sencilla, clara y ordenada, de escribir la poesía sería la siguiente:
Programa:
printf("%s\n%s\n%s\n%s\n",
"Con cien cañones por banda,",
"viento en popa a toda vela,",
"no cruza el mar sino vuela,",
"un velero bergantín.");
Resultado:
Con cien cañones por banda,
viento en popa a toda vela,
no cruza el mar sino vuela,
un velero bergantín.
En este caso se están escribiendo 4 cadenas constantes de caracteres que se introducen
como argumentos, con formato %s y con los correspondientes saltos de línea.
Un ejemplo que contiene una constante y una variable como argumentos es el siguiente:
Programa:
float beneficios=1523.2345;
printf("En el año %s ganó %5.2f dólares.\n", "1993", beneficios);
Resultado:
En el año 1993 ganó 1523.23 dólares.
Donde el texto 1993 se imprime como cadena de caracteres (%s), mientras que beneficios se
imprime con formato de variable float (%f) con dos dígitos de precisión.
Es importante hacer corresponder bien los formatos con el tipo de los argumentos, pues si no
los resultados pueden ser muy diferentes de lo esperado.
La función printf() tiene un valor de retorno de tipo int, que representa el número de caracteres
escritos en esa llamada.

Las secuencias de escape más utilizadas en C son:
Nombre completo Secuencia de escape
sonido de alerta \a
nueva línea \n
tabulador horizontal \t
retroceso \b
retorno de carro \r
salto de página \f
barra invertida \\
apóstrofo \’
comillas \”
carácter nulo \0
FUNCIÓN SCANF()
Aca se escribe el nombre de la variable

en donde se guardara el dato ingresado
I por teclado
La función scanf() es análoga en muchos aspectos a printf(), y se utiliza para leer datos de la
entrada estándar (que por defecto es el teclado). La forma general de esta función es la
siguiente:
int scanf("%x1%x2...", &arg1, &arg2, ...);
Donde x1, x2, ... son los caracteres de conversión, mostrados en la tabla, que representan los
formatos con los que se espera encontrar los datos. La función scanf() devuelve como valor de
retorno el número de conversiones de formato realizadas con éxito. La cadena de control de
scanf() puede contener caracteres además de formatos. Dichos caracteres se utilizan para
tratar de detectar la presencia de caracteres idénticos en la entrada por teclado. Si lo que se
desea es leer variables numéricas, esta posibilidad tiene escaso interés. A veces hay que
comenzar la cadena de control con un espacio en blanco para que la conversión de formatos
se realice correctamente.
En la función scanf() los argumentos que siguen a la cadena_de_control deben ser pasados
por referencia, ya que la función los lee y tiene que trasmitirlos al programa que la ha llamado.
Para ello, dichos argumentos deben estar constituidos por las direcciones de las variables en
las que hay que depositar los datos, y no por las propias variables. Una excepción son las
cadenas de caracteres, cuyo nombre es ya de por sí una dirección (un puntero), y por tanto no
debe ir precedido por el operador (&) en la llamada.

Carácter Caracteres leído
c cualquier carácter
d,i entero decimal con signo
u entero decimal sin signo
o entero octal
x,X entero hexadecimal
e, E, f, g, G número de punto flotante
s cadena de caracteres sin ' '
h, l para short, long y double
L modificador para long double
Por ejemplo, para leer los valores de dos variables int y double y de una cadena de caracteres,
se utilizarían la sentencia:
int n;
double distancia;
char nombre[20];
scanf("%d%lf%s", &n, &distancia, nombre);
En la que se establece una correspondencia entre n y %d, entre distancia y %lf, y entre nombre
y %s. Obsérvese que nombre no va precedido por el operador (&). La lectura de cadenas de
caracteres se detiene en cuanto se encuentra un espacio en blanco, por lo que para leer una
línea completa con varias palabras hay que utilizar otras técnicas diferentes.
En los formatos de la cadena de control de scanf() pueden introducirse corchetes [...], que se
utilizan como sigue:
scanf("%[AB \n\t]s", nombre); // se leen solo los caracteres indicados
Lee caracteres hasta que encuentra uno diferente de (’A’,’B’,’ ’,’\n’,’\t’). En otras
palabras, se leen sólo los caracteres que aparecen en el corchete. Cuando se encuentra un
carácter distinto de éstos se detiene la lectura y se devuelve el control al programa que llamó a
scanf(). Si los corchetes contienen un carácter (^), se leen todos los caracteres distintos de los
caracteres que se encuentran dentro de los corchetes a continuación del (^). Por ejemplo, la
sentencia,
scanf(" %[^\n]s", nombre);
Lee todos los caracteres que encuentra hasta que llega al carácter nueva línea ’\n’. Esta
sentencia puede utilizarse por tanto para leer líneas completas, con blancos incluidos.
Recuérdese que con el formato %s la lectura se detiene al llegar al primer delimitador (carácter
blanco, tabulador o nueva línea).

ESTRUCTURAS SELECTIVA
Una de las estructuras importantes que pueden utilizarse en un programa son las selectivas y
radican en el hecho de realizar diferentes tareas en función de ciertas condiciones. Esto es,
ejecutar una parte del código u otra, condicionalmente. Para ello será necesario especificar
dichas condiciones y disponer de un mecanismo para indicar qué acciones tomar dependiendo
de cómo se evalúe una determinada condición en un momento dado de la ejecución del
programa.
FUNCIÓN IF
Verdadero Falso
IF (Condición)
Procedimiento
El formato general de esta estructura IF() para decidir si una determinada sentencia debe
ejecutarse o no (alternativa simple) es el siguiente:
if (condicion)
sentencia; /*Se ejecuta si la condición es verdadera*/
La construcción if puede escribirse también de forma más general para controlar la ejecución
de un grupo de sentencias, de la siguiente manera:
if (condicion)
{
sentencia 1; /*Se ejecutan si la condición es verdadera*/
sentencia 2;
. . .
sentencia n;
}
El funcionamiento de la construcción if es muy simple. En primer lugar se evalúa la
condición, que no es otra cosa que una expresión de tipo entero. A continuación, si la
expresión se ha evaluado como verdadera, se ejecuta la sentencia o grupo de sentencias. En
caso contrario la ejecución del programa continúa por la siguiente sentencia en orden
secuencial.

El siguiente ejemplo muestra el uso de la función if. El programa lee un número entero y lo
transforma en el impar inmediatamente mayor, si es que no era ya impar.
Programa:
int main(int argc, char *argv[])
{
int a;
scanf("%d", &a);
if (a % 2 == 0) /* Corroboro si a es par. */
a = a + 1; /*Si a es par le sumo 1*/
printf( "Ahora es impar: %d\n", a );
system("PAUSE");
return 0;
}
Resultado:
2
Ahora es impar: 3
Presione una tecla para continuar . . .
Nótese que después de la función if (condición) no se escribe ‘;’ (punto y coma).
FUNCION IF-ELSE
Verdadero Falso (Else)

IF (Condición)
Procedimiento Procedimiento
Existe otra forma más general, denominada alternativa doble, que ofrece dos alternativas de
ejecución, en función de si la condición se evalúa verdadera o falsa.
if (condicion)
sentencia 1; /*Se ejecuta si la condición es verdadera*/
else
sentencia 2; /*Se ejecuta si la condición es falsa*/

La construcción if-else puede escribirse también de forma más general para controlar la
ejecución de un grupo de sentencias, de la siguiente manera:
if (condicion)
{
grupo sentencias 1; /*Se ejecutan si la condición es verdadera*/
}
else
{
grupo sentencias 2; /*Se ejecutan si la condición es falsa*/
}
Así pues, si la condición es verdadera se ejecutará la primera sentencia o el primer grupo de
sentencias, y si es falsa se ejecutará la segunda sentencia o el segundo grupo de sentencias.
El siguiente programa muestra el uso de la función if-else. El programa calcula el máximo de
dos números enteros:
Programa:
{
int a, b, max;
scanf( "%d %d", &a, &b );
if (a>b)
max = a;
else
max = b;
printf( "\nEl máximo es: %d\n", max );
system("PAUSE");
return 0;
}
Resultado:
2
4
El máximo es: 4

FUNCION IF-ELSE-IF
Existe finalmente otra construcción alternativa muy común, conocida como if-else-if o
simplemente else-if. Su construcción se muestra a continuación:
if (condicion 1)
{
grupo de sentencias 1;
}
else if (condicion 2)
{
}
else if (condicion 3)
{
}
else if (condicion n)
{
grupo de sentencias n;
}
else
{
grupo de sentencias por defecto;
}
Las condiciones se evalúan secuencialmente de arriba hacia abajo hasta encontrar una que dé
como resultado verdadero. En ese punto, se ejecuta el grupo de sentencias correspondiente a
dicha condición. El resto de condiciones y sentencias asociadas se ignoran. En caso de que
ninguna de las condiciones se evalúe verdadera, se ejecutaría el grupo de sentencias por
defecto. Como en todos los casos anteriores, el último else es opcional.
A continuación se muestra un ejemplo del uso de esta construcción:
int hora;
scanf("%d", &hora );
if((hora>=0)&&(hora<12)) /*Si 0<hora<12*/
printf( "Buenos días" ); /*Imprimo Buenos días*/
else if((hora>=12)&&(hora<18)) /*Sino, Si 12<hora<18*/
printf( "Buenas tardes" ); /*Imprimo Buenas tardes*/
else if ((hora >= 18) && (hora < 24)) /*Sino, Si 18<hora<24*/
printf( "Buenas noches" ); /*Imprimo Buenas noches*/
else /*Sino,…*/
printf( "Hora no válida" ); /*Imprimo Hora no válida*/

EL OPERADOR CONDICIONAL ?
El operador condicional ? es el único operador ternario de C. La forma general de las
expresiones construidas con este operador es la siguiente:
expresion1 ? expresion2 : expresion3;
De manera que si la primera expresión se evalúa verdadera, toda la expresión toma el valor de
la segunda expresión. En cambio, si la primera expresión se evalúa falsa, toda la expresión
toma el valor de la tercera expresión.
Un ejemplo típico del uso de este operador es el cálculo del máximo de dos valores. En la
siguiente sentencia, C toma el valor del máximo entre la variable a y b.
c = (a > b)? a : b;
Esto mismo podría haberse escrito usando la función if-else como:
if (a>b)
c = a;
else
c = b;
De esta manera, algunas sentencias if-else sencillas pueden escribirse de manera muy
compacta mediante el operador ?.
Finalmente, el operador condicional, por ser en realidad un operador para expresiones, puede
usarse en lugares donde no puede usarse un if-else, como se muestra a continuación:
printf("El mínimo es %d \n", ((x < y) ? x : y)); /*Si la expresión x<y
es verdadera se imprime el valor de x, de lo contrario se imprime el
valor de y.*/

FUNCIÓN SWITCH
Switch (Condición)
Default 6 5 4 3 2 1
Procedimiento 1
Procedimiento 2
Procedimiento 3
Procedimiento 4
Procedimiento 5
Procedimiento 6
Procedimiento Default
Esta construcción permite especificar múltiples sentencias al estilo if-else-if, pero de

manera más compacta, legible y elegante. Su forma general es la siguiente:
switch ( expresion )
{
case constante 1 :
break;
case constante 2 :
break;
case constante 3 :
break;
…………………
case constante n :
grupo de sentencias n;
break;
default :
grupo de sentencias por defecto;
break;
}
Donde la expresión debe ser de tipo entero o carácter, al igual que todas las constantes
asociadas a cada etiqueta case. Es importante resaltar que no pueden usarse variables o
expresiones en los distintos case, sino sólo constantes.

El funcionamiento de la función switch es como sigue. En primer lugar se evalúa la

expresión. Seguidamente su valor es comparado secuencialmente con el de las diferentes
constantes en los case. Si el valor de la expresión coincide con alguna de ellas, se ejecuta el
grupo de sentencias correspondiente y el switch concluye gracias a la sentencia break. En
caso contrario, y si existe el caso default (que es opcional), se ejecutaría el grupo de
sentencias por defecto.
Cabe recordar la sentencia break en general se utiliza para finalizar de forma forzada la
ejecución dentro de un bloque de código, de manera que la siguiente sentencia a ejecutar será
la primera sentencia justo después de dicho bloque. En la construcción switch, break es
necesario para concluir la ejecución del grupo de sentencias asociado al case cuya constante
coincide con el valor de la expresión. Así pues, la sentencia a ejecutar después de break en
un switch, será la primera sentencia posterior a la llave que cierra el switch.
g
El siguiente ejemplo muestra un programa que hace uso de switch para traducir a caracteres
un dígito entre 1 y 5:
int num;
scanf( "%d", &num );
switch ( num )
{
case 1 :
printf( "Uno.\n" );
break;
case 2 :
printf( "Dos.\n" );
break;
case 3 :
printf( "Tres.\n" );
break;
case 4 :
printf( "Cuatro.\n" );
break;
case 5 :
printf( "Cinco.\n" );
break;
default :
printf( "El dígito está fuera de rango.\n" );
break;
}

Finalmente, cabe decir que el grupo de sentencias asociado a un case puede ser vacío. Este
caso particular tiene su utilidad cuando se desea que varias etiquetas case ejecuten un
mismo grupo de sentencias. Por ejemplo:
int num;
switch ( num )
{
case 1 :
case 3 :
case 7 :
printf( "Uno, Tres o Siete.\n" );
break;
case 4 :
case 8 :
printf( "Cuatro u Ocho.\n" );
break;
case 9 :
printf( "Nueve.\n" );
break;
default :
printf( "El dígito está fuera de rango.\n" );
break;
}

ESTRUCTURAS REPETITIVAS
Además de bifurcaciones, en el lenguaje C existen también varias sentencias que permiten
repetir una serie de veces la ejecución de unas líneas de código. Esta repetición se puede
realizar, o bien un número fijo determinado de veces, o bien hasta que se cumpla una
determinada condición de tipo lógico o aritmético. De modo genérico, a estas sentencias se les
denomina bucles. Las tres construcciones del lenguaje C para realizar bucles son el while, el
for y el do...while.
SENTENCIA WHILE
While (Condición) Falso
Verdadero
Procedimiento
Esta sentencia permite ejecutar repetidamente, mientras se cumpla una determinada condición,
una sentencia o bloque de sentencias. La forma general es como sigue:
while (condición)
sentencia;
O para la ejecución repetida de un grupo de sentencias:
while (condición)
{
grupo de sentencias;
}
El funcionamiento de esta construcción es bastante simple. El cuerpo del bucle, es decir, la
sentencia o grupo de sentencias dentro del bucle, se ejecuta mientras el valor de la expresión
que actúa de condición sea verdadero. En el momento en que la condición sea falsa, la
ejecución del programa continúa secuencialmente con la siguiente instrucción posterior al
bucle.

El siguiente ejemplo calcula la media de una secuencia de números enteros leídos por teclado.
La secuencia finaliza en -1
Programa:
#include <stdio.h>
void main()
{
int num, cont, suma;
cont = 0;
suma = 0;
while (num != -1)
{
cont++;
suma = suma + num;
}
if (cont != 0)
printf( "La media es %d\n", sum/cont );
else
printf( "La secuencia es vacía\ n" ); n
}
En la construcción while la condición se evalúa al principio del bucle. Por ello, si cuando se
alcanza el bucle por primera vez, la condición es falsa, el cuerpo del bucle no se ejecuta nunca
(imagínese el caso, en el ejemplo anterior, en que el primer número de la secuencia sea -1).
como consecuencia, el cuerpo de un bucle while puede ejecutarse entre 0 y n veces, donde
n depende de la condición. Nótese también que si la condición permanece cierta, el bucle
puede no terminar nunca (imagínese qué ocurriría si se elimina la sentencia scanf del cuerpo
del bucle del ejemplo anterior). Por ello, habitualmente las sentencias del cuerpo del bucle
modifican las variables que aparecen en la condición, de forma que ésta sea falsa en algún
momento.
Otro ejemplo podría ser un programa que nos diga si cada número que ingresamos es positivo
o negativo, y que pare cuando ingresemos el número 0, esto podría ser:
Programa:
#include <stdio.h>
main()
{
int numero;
printf("Teclea un número (0 para salir): ");
scanf("%d", &numero);
while (numero!=0)
{
if (numero > 0)
printf("Es positivo\n");
else
printf("Es negativo\n");
printf("Teclea otro número (0 para salir): ");
scanf("%d", &numero);
}
{

Resultado:
Teclea un número (0 para salir): 2
Es positivo
Teclea otro número (0 para salir): 8
Es positivo
Teclea otro número (0 para salir): -9
Es negativo
Es negativo
Es positivo
Es negativo
Es positivo
Es negativo
En este ejemplo, si se introduce 0 la primera vez, la condición es falsa y ni siquiera se entra al
bloque del “while”, terminando el programa inmediatamente.
Resultado: (2):
Teclea un número (0 para salir): 0

SENTENCIA DO-WHILE
Do-Procedimiento
Falso
While (Condición)
Verdadero
Esta sentencia funciona de modo análogo a While, con la diferencia de que la evaluación de
condición se realiza al final del bucle, después de haber ejecutado al menos una vez las
sentencias entre llaves; éstas se volverán a ejecutar mientras la condición sea verdadera. La
forma general de esta sentencia es:
Do
{
sentencia o grupo de sentencias;
}
while (condición);
Nótese que tanto para ejecutar una sola sentencia como para ejecutar un grupo de ellas, las
llaves { } son igualmente necesarias. Esta construcción funciona de manera muy similar a la
construcción while. Sin embargo, al contrario de ésta, Do-While ejecuta primero el cuerpo
del bucle y después evalúa la condición. Por lo cual, el cuerpo del bucle se ejecuta como
mínimo vez.
1
El siguiente ejemplo cuenta el número de veces que aparece el valor 3 en una secuencia de
números enteros acabada en -1

Programa:
#include <stdio.h>
void main()
{
int num, cont;
cont = 0;
do
{
if (num == 3)
cont++;
}
while (num != -1);
printf( "El 3 se ha ingresado %d veces\n", cont );
}
Resultado:
2
4
6
3
8
1
2
3
5
77
569
3
21
0
78
-1
El 3 se ha ingresado 3 veces
Es importante destacar el uso de ‘;’ después de la condición, a diferencia de la construcción
While, donde no se utiliza.
Finalmente, cabe decir que tradicionalmente, tanto la sentencia While como la sentencia
Do-while se utilizan cuando se desconoce de entrada el número exacto de iteraciones
repetitivas.

Como ejemplo, vamos a ver cómo sería el típico programa que nos pide una clave de acceso y
no nos deja entrar hasta que ingresemos la clave correcta. La clave será un número:
Programa:
#include <stdio.h>
main()
{
int valida = 711;
int clave;
do
{
printf("Introduzca su clave numerica: ");
scanf("%d", &clave);
if (clave != valida)
printf("No valida!\n");
}
while (clave != valida);
printf("Aceptada.\n");
}
Resultado:
Introduzca su clave numerica: 12
No valida!
No valida!
No valida!
No valida!
Aceptada.
En este caso, se comprueba la condición al final, de modo que se nos preguntará la clave al
menos una vez. Mientras que la respuesta que demos no sea la correcta, se nos vuelve a
preguntar. Finalmente, cuando tecleamos la clave correcta, el ordenador escribe “Aceptada” y
termina el programa.
Resultado: (2):
Aceptada.

SENTENCIA FOR
For (Cond. inicial; Cond. escape; Paso)
Procedimiento
Ésta es la sentencia que usaremos habitualmente para crear partes del programa que se
repitan un cierto número de veces ya conocido con anterioridad. El formato de “for” es:
for (condición inicial ; condición de escape ; paso)
sentencia;
O para la ejecución repetida de un grupo de sentencias:
for (condición inicial ; condición de escape ; paso)
{
grupo de sentencias;
}
La primera parte de la sentencia for acostumbra a ser una sentencia de asignación donde se
inicializa alguna variable que controla el número de veces que debe ejecutarse el cuerpo del
bucle, ósea, se establece la condición inicial. Esta sentencia se ejecuta una sola ocasión, antes
de entrar por primera vez al cuerpo del bucle.
La segunda parte corresponde a la condición de escape que indica cuándo finaliza el bucle, de
la misma forma que en las construcciones iterativas anteriores. En este caso, la condición se
evalúa antes de ejecutar el cuerpo del bucle o grupo de sentencias, por lo que al igual que en
la construcción While, el cuerpo puede ejecutarse entre 0 y n veces, donde n depende de la
condición.
La tercera parte corresponde normalmente a una sentencia del paso que llevara la variable de
control, generalmente un incremento o decremento. Esta sentencia se ejecuta siempre
después de la ejecución del cuerpo del bucle.
El programa del siguiente ejemplo utiliza la construcción for para calcular la sumatoria de los
números que van del 1 al 10, elevados al cuadrado:

Programa:
#include <stdio.h>
void main()
{
int i, cuadrado, suma;
suma = 0;
for (i = 0 ; i <= 10 ; i++)
{
cuadrado = i * i;
suma = suma + cuadrado;
printf("La sumatoria parcial hasta”
“ el numero %d es: %d\n", i,suma);
}
printf("La sumatoria es %d\n", suma );
}
Resultado:
La sumatoria parcial hasta el número 0 es: 0
El sumatorio es 385
Finalmente, cabe decir que tradicionalmente la sentencia For se utiliza cuando se conoce de
entrada el número exacto de iteraciones repetitivas a realizar.
El operador coma (,)

C permite la utilización de más de una sentencia en la primera y tercera partes de la
construcción for, así como de más de una condición en la segunda parte. Por ejemplo, el
siguiente bucle es válido en C:
for (i = 0, j = 10 ; i < 10, j > 0 ; i++, j-=2)
{
/* Grupo de sentencias */
}
Así pues, las variables i y j se inicializan a 0 y 10 respectivamente, antes de comenzar la
ejecución del bucle. En la segunda parte de la construcción, aparecen dos condiciones, i<10
y j>0. Si alguna de ellas es falsa, la ejecución del bucle se detiene. Finalmente, tras ejecutarse
el cuerpo del bucle, i se incrementa en 1 y j se decrementa en 2 tras lo cual vuelven a
comprobarse las condiciones, y así sucesivamente.
Otro ejemplo útil seria con bucles For anidados. Podríamos, por ejemplo, realizar un programa
que nos muestre las tablas de multiplicar del 1 al 4:

Programa:
#include <stdio.h>
main()
{
int tabla, numero;
for (tabla=1; tabla<=4; tabla++)
{
for (numero=1; numero<=10; numero++)
printf("%dx%d=%d\n", tabla, numero, tabla*numero);
printf("\n");
}
}
Resultado:
1x1=1
1x2=2
1x3=3
1x4=4
1x5=5
1x6=6
1x7=7
1x8=8
1x9=9
1x10=10
2x1=2
2x2=4
2x3=6
2x4=8
2x5=10
2x6=12
2x7=14
2x8=16
2x9=18
2x10=20
3x1=3
3x2=6
3x3=9
3x4=12
3x5=15
3x6=18
3x7=21
3x8=24
3x9=27
3x10=30
4x1=4
4x2=8
4x3=12
4x4=16
4x5=20
4x6=24
4x7=28
4x8=32
4x9=36
4x10=40

SENTENCIA BREAK Y CONTINUE

C proporciona dos mecanismos para alterar la ejecución de las estructuras repetitivas, las
sentencias break y continue.
Break
Esta sentencia tiene una doble finalidad. Por un lado, indica el final de un Case en la
construcción Switch, como ya se vio con anterioridad. Y por otro, para forzar la terminación
inmediata de la ejecución de un bucle. De esta forma, se permite salir de la estructura repetitiva
ignorando la evaluación de la condición. Si bien su uso está reconocido como no muy elegante,
permite en ocasiones escribir programas más legibles y compactos.
Continue
Esta sentencia se utiliza únicamente en las estructuras repetitivas. Su función es la de evitar
que se ejecute todo el código a continuación de ella y hasta el final del cuerpo del bucle,
durante una iteración determinada.
El siguiente ejemplo pretende ilustrar el uso de estas sentencias:
Programa:
#include <stdio.h>
#include <stdlib.h>
{
int num;
do
{
scanf("%d",&num);
if(num<0)
{
printf("\nEl valor es negativo, termino el bucle!\n");
break;
}
if(num>100)
{
printf("\nEl valor es muy grande, termino la iteracion\n");
continue;
}
printf("Este cartel se vera si no se produjo"
" ni el break ni el continue\n");
}
while(num!=0);
return 0;
}
Resultado:
6
Este cartel se vera si no se produjo ni el break ni el continue
105
El valor es muy grande, termino la iteracion
99
Este cartel se vera si no se produjo ni el break ni el continue
-48
El valor es negativo, termino el bucle!

Otro ejemplo exclusivo del break, seria:

Programa:
#include <stdio.h>
#include <stdlib.h>
{
int i;
for (i=0; i<=10; i++)
{
if(i==5)
break;
printf("%d ", i);
}
system("PAUSE");
return 0;
}
Resultado:
0 1 2 3 4 Presione una tecla para continuar . . .
Y, un ejemplo exclusivo del continue, seria:
Programa:
#include <stdio.h>
#include <stdlib.h>
{
int i;
for (i=0; i<=10; i++)
{
if (i==5)
continue;
printf("%d ", i);
}
system("PAUSE");
return 0;
}
Resultado:
0 1 2 3 4 6 7 8 9 10 Presione una tecla para continuar . . .

SENTENCIA GOTO
El lenguaje C también permite la orden “goto”, para hacer saltos incondicionales. Su uso
indisciplinado está muy mal visto, porque puede ayudar a hacer programas llenos de saltos,
difíciles de seguir. Pero en casos concretos puede ser muy útil, por ejemplo, para salir de un
bucle muy anidado (un “for” dentro de otro “for” que a su vez está dentro de otro “for”: en este
caso, “break” sólo saldría del “for” más interno).
El formato de “goto” es:
goto Pepe;
y la posición de salto se indica con su nombre seguido de dos puntos (:)
Pepe:
Como en el siguiente ejemplo:
Programa:
#include <stdio.h>
#include <stdlib.h>
{
int i, j;
for (i=0; i<=5; i++)
for (j=0; j<=20; j+=2)
{
if ((i==1) && (j>=7))
goto salida;
printf("i vale %d y j vale %d.\n", i, j);
}
salida:
printf("Fin del programa\n");
system("PAUSE");
return 0;
}
Resultado:
i vale 0 y j vale 0.
Fin del programa
Vemos que cuando i=1 y j>=7, se sale de los dos “for” sin que ninguno de ellos haya llegado a
finalizar el bucle para el cual fueron calibrados.

TIPOS DE DATOS ESTRUCTURADOS

Comenzaremos hablando del tipo abstracto de datos estructurados, tanto de una dimensión
(vector o array), dos dimensiones (matriz) o múltiples dimensiones.
VECTOR O ARRAY
Los vectores, también llamados tablas unidimensionales, son estructuras de datos
caracterizadas por ser:
• Una colección de datos del mismo tipo.
• Referenciados mediante un mismo nombre.
• Almacenados en posiciones de memoria físicamente contiguas, de forma que, la
dirección de memoria más baja corresponde a la del primer elemento, y la dirección de
memoria más alta corresponde a la del último elemento.
El formato general para la declaración de una variable de tipo vector es el siguiente:
tipo de datos nombre array [tamaño];
Donde:
• tipo de datos: indica el tipo de los datos almacenados por el vector. Recordemos
que todos los elementos del vector son forzosamente del mismo tipo. Debe aparecer
necesariamente en la declaración, puesto que de ella depende el espacio de memoria
que se reservará para almacenar el vector. Por ejemplo: Int, Float o Char.
• nombre array: es un identificador que usaremos para referiremos tanto al array
como un todo, como a cada uno de sus elementos. Por ejemplo: notas, fechas,
nombres.
• tamaño: es una expresión entera constante que indica el número de elementos que
contendrá el vector. El espacio ocupado por un vector en memoria se obtiene como el
producto del número de elementos que lo componen y el tamaño de cada uno de éstos.
0 1 2 3 4 N-1
. . . .
Primer elemento Último elemento
del vector del vector
Representación grafica de un vector de N elementos.
Consulta de un array
El acceso a un elemento de un array se realiza mediante el nombre de éste y un índice entre
corchetes ([índice]). El índice representa la posición relativa que ocupa dicho elemento dentro
del vector y se especifica mediante una expresión entera (normalmente una constante o una
variable).

A continuación se muestran algunas formas válidas de acceso a los elementos de un vector:

Programa:
int contador[10];
int i, j, x;
. . .
x = contador[1]; /*coloco en x el segundo valor del array contador*/
x = contador[i]; /*coloco en x el valor que se encuentra en la
posición definida por ‘i’*/
x = contador[i * 2 + j]; /*coloco en x el valor que se encuentra en la
posición definida por ‘i*2+j’*/
. . .
Como muestra la figura, el primer elemento de un vector en C se sitúa en la posición 0(cero),
mientras que el último lo hace en la posición N-1 (N indica el número de elementos del vector).
Por esta razón, el índice para acceder a los elementos del vector debe permanecer entre estos
dos valores. Es responsabilidad del programador garantizar este hecho, para no acceder a
posiciones de memoria fuera del vector, lo cual produciría errores imprevisibles en el programa.
Asignación de datos a un array

La asignación de valores a los elementos de un array se realiza de forma similar a como se
consultan. Veámoslo en un ejemplo:
Programa:
int contador[3];
. . .
contador[0] = 24; /*asigno el valor 24 a la primer posición del
array*/
contador[1] = 12; /*asigno el valor 12 a la segunda posición del
array*/
contador[2] = 6; /*asigno el valor 06 a la tercera posición del
array*/
En muchas ocasiones, antes de usar un array (o cualquier tipo de dato estructurado) por
primera vez, es necesario dar a sus elementos un valor inicial. La manera más habitual de
inicializar un vector en tiempo de ejecución consiste en recorrer secuencialmente todos sus
elementos y darles el valor inicial que les corresponda. Veámoslo en el siguiente ejemplo,
donde todos los elementos de un vector de números enteros toman el valor 0 (cero):
Programa:
void main()
{
int vector[100], i;
for (i= 0; i< 100; i++)
vector[i] = 0;
}
Nótese que el bucle recorre los elementos del vector empezando por el elemento 0 (i=0) y
hasta el elemento 100-1 (condición de salida del bucle for; i<100).
Existe también un mecanismo que permite asignar un valor a todos los elementos de un array
con una sola sentencia. Concretamente en la propia declaración del array.
La forma general de inicializar un arreglo de datos array es la siguiente:
tipo de datos nombre del array [tamaño] = { lista valores};
La lista de valores no deberá contener nunca más valores de los que puedan almacenarse en
la tabla. Veamos algunos ejemplos:

int contador[3] = {24, 12, 6}; /* Correcto */

char vocales[5] = {’a’, ’e’, ’i’, ’o’, ’u’}; /* Correcto */
int v[4] = {2, 6, 8, 9, 10, 38}; /* Incorrecto */
Finalmente remarcamos que los mecanismos de acceso descriptos en esta sección son
idénticos para las matrices y las tablas multidimensionales. La única diferencia es que será
necesario especificar tantos índices como dimensiones posea el arreglo al que se desea
acceder. Esto lo veremos en las siguientes secciones.
A continuación se muestra un ejemplo de un programa que almacena 15 valores enteros y
encuentra el mayor de estos.
Programa:
#include <stdio.h>
#include <stdlib.h>
{
int numero[15],num_mayor=0,i;
for(i=0;i<15;i++)
{
scanf("%d", &numero[i]);
if (numero[i]> num_mayor)
num_mayor=numero[i];
}
printf( "El mayor de los 15 números ingresados es: %d", num_mayor);
system("PAUSE");
return 0;
}
Resultado:
2
5
3
18
6
489
178
789
15
38
331
55
22
147
233
El mayor de los 15 números ingresados es: 789
Otro ejemplo consiste en un programa que inicializa dos array de 100 elementos en cero, luego
carga en uno de ellos 100 valores ingresados por teclado, a continuación calcula y almacena
en el otro array el cuadrado de los números ingresados para finalmente mostrar el resultado de
la operación en pantalla.

Programa:
#include <stdio.h>
#include <stdlib.h>
{
int numero_normal[100],numero_cuadrado[100],i;
for(i=0;i<100;i++)
{
numero_normal[i]=0;
numero_cuadrado[i]=0;
}
for(i=0;i<100;i++)
scanf("%d", &numero_normal[i]);
for(i=0;i<100;i++)
numero_cuadrado[i]=numero_normal[i]*numero_normal[i];
for(i=0;i<100;i++)
printf("%d^2=%d\n",numero_normal[i],numero_cuadrado[i]);
system("PAUSE");
return 0;
}
Resultado:
Queda como tarea del alumno observar el comportamiento de este
programa.
MATRIZ O ARRAY BIDIMENSIONAL

Las matrices, también llamadas array bidimensionales, no son otra cosa que vectores con dos
dimensiones.
Por lo que los conceptos de acceso, inicialización, etc. son similares.
La declaración de una variable matriz tiene la forma siguiente:
Tipo_de_datos nombre_tabla [tamaño dim1][tamaño dim2];
Donde tamaño dim1 y tamaño dim2 indican, respectivamente, el número de filas y de columnas
que componen la matriz. La figura muestra la representación gráfica habitual de una matriz de
datos.
Otro hecho importante es que las matrices en C se almacenan “por filas”. Es decir, que los
elementos de cada fila se sitúan en memoria de forma contigua. Así pues, en la matriz de la
figura anterior, el primer elemento almacenado en memoria es el (0,0), el segundo el (0,1), el
tercero el (0,2), . . . ,(0,M-1), después (1,0), y así sucesivamente hasta el último elemento, es
decir (N-1,M-1).

Primer elemento
de la matriz
0 1 2 3 4 M-1
0 . . . .
0 . . . .
0 . . . .
0 . . . .
0 . . . .
. . . .
. . . .
N-1 . . . .
Último elemento
de la matriz
Representación grafica de una matriz de N filas y M columnas.
Consulta
El acceso a un elemento de una matriz se realiza mediante el nombre de ésta y dos índices
(uno para cada dimensión) entre corchetes. El primer índice representa la fila y el segundo la
columna en que se encuentra dicho elemento. Tal como muestra la figura, el índice de las filas
tomará valores entre 0 y el número de filas menos 1, mientras que el índice de las columnas
tomará valores entre 0 y el número de columnas menos 1. Es responsabilidad del programador
garantizar este hecho.
nombre matriz[índice 1][índice 2];
Asignación
Comentaremos únicamente la inicialización de una matriz en la propia declaración. El siguiente
ejemplo declara una matriz de tres filas y cuatro columnas y la inicializa. Por claridad, se han
expresado los datos por filas, aunque se puede escribir todos en una sola línea.
int mat[3][4] = {24, 12, 6, 17,
15, 28, 78, 32,
0, 44, 3200, -34
}
La inicialización de matrices, y en general de tablas multidimensionales, puede expresarse de
forma más clara agrupando los valores mediante llaves ({}g), siguiendo la estructura de la
matriz. Así pues, el ejemplo anterior también podría escribirse como:
int mat[3][4] = { {24, 12, 6, 17},
{15, 28, 78, 32},
{0, 44, 3200 , -34}
};

El siguiente programa muestra como se cargan las 3 notas de herramientas informáticas de los
50 alumnos numerados según el listado de bedelia. Estos datos se cargaran en una matriz.
Programa:
#include <iostream>
#include <stdlib.h>
using namespace std;
{
int i,j,num_alumno;
int notas[50][3];
for(i=0;i<50;i++)
for(j=0;j<3;j++)
notas[i][j]=0;
printf("\nIngrese el numero del alumno al cual quiere”
“ ingresarle las notas: ");
printf("\nIngrese cero (0) para terminar ");
scanf("%i",&num_alumno);
while(num_alumno!=0)
{
for(i=0;i<3;i++)
{
printf("Ingrese la nota numero %d: ",i+1);
scanf("%i",&notas[num_alumno-1][i]);
}
printf("\nIngrese el numero del alumno al cual quiere”
“ ingresarle las notas: ");
printf("\nIngrese cero (0) para terminar ");
scanf("%i",&num_alumno);
}
for(i=0;i<50;i++)
{
printf("\nLas notas del alumno %d son: ",i+1);
for(j=0;j<3;j++)
{
printf("%i ",notas[i][j]);
}
}
system("PAUSE");
return 0;
}
Resultado:
Queda como tarea del alumno observar el comportamiento de este
programa.
ARREGLOS MULTIDIMENCIONALES
Este tipo de arreglos se caracteriza por tener tres o más dimensiones.
Al igual que vectores y matrices, todos los elementos almacenados en ellas son del mismo tipo
de datos.
La declaración de una tabla multidimensional tiene la forma siguiente:
Tipo_de_datos nombre_tabla [tamaño dim1].....[tamaño dimN];
No esta en el alcance de este curso este tipo de arreglos, por lo quedará a criterio del alumno
profundizar sobre este tema.
FUNCIONES
Hasta ahora hemos visto como el programa principal (main()) utiliza funciones de la librería
estándar de C para realizar algunas tareas comunes (printf(), scanf(), . . . ). C permite

también la definición de funciones por parte del programador. Como veremos, al usar funciones
definidas por el programador, los programas pueden estructurarse en partes más pequeñas y
sencillas. Cada una de estas partes debe responder a un propósito único e identificable,
pudiendo además utilizarse en distintos lugares del programa principal. La distribución del
código de un programa usando funciones se conoce como modularización.
El diseño modular de programas ofrece diversas ventajas. Por ejemplo, muchos programas
requieren la ejecución de un mismo grupo de instrucciones en distintas partes del programa.
Este grupo de instrucciones puede incluirse dentro de una sola función, a la que se puede
llamar cuando sea necesario.
Además, puede proporcionarse un conjunto de datos (parámetros) diferente a la función cada
vez que se la llama.
Es importante también la claridad en la lógica del programa resultante de la descomposición
del mismo en partes bien definidas. Un programa concebido de esta forma es mucho más fácil
de escribir y de depurar, no sólo por el propio programador, sino también (y más importante)
por otros programadores que posteriormente deban mantener el programa. Este hecho es
especialmente cierto en programas grandes donde participan muchos programadores.
La utilización de funciones permite también la construcción a medida de librerías de funciones
de uso frecuente. Por ejemplo, un programador especializado en el desarrollo de programas
matemáticos podría crear una librería con funciones para el manejo de matrices, números
complejos, etc. De esta forma se evita la reescritura del mismo código repetidas veces para
distintos programas.
Una función es una porción de programa, identificable mediante un nombre, que realiza
determinadas tareas bien definidas por un grupo de sentencias sobre un conjunto de datos. Las
operaciones que realiza la función son siempre las mismas, pero los datos pueden variar cada
vez que se llame a la función. Todo programa en C consta de una o mas funciones, una (y sólo
una) de la cuales debe llamarse main.
La ejecución del programa comienza siempre en dicha función, desde donde puede llamarse a
otras funciones de la librería estándar o funciones definidas por el programador. Al llamar a una
función se ejecutan las sentencias que la componen y, una vez completada la ejecución de la
función, la ejecución del programa continúa desde el punto en que se hizo la llamada a la
función.
Generalmente, al llamar a una función se le proporciona un conjunto de datos (parámetros) que
se procesan ejecutando las sentencias que la componen. La función devuelve un solo valor
mediante la sentencia return. Algunas funciones reciben parámetros, pero no devuelven nada,
mientras que otras no reciben parámetros pero síı devuelven un valor.
Definición de una función.

La definición de una función se hace de forma similar a la de la función main(). Su forma más
genérica consta básicamente de dos partes: un línea llamada cabecera donde se especifica el
nombre de la función, el tipo del resultado que devuelve y los parámetros que recibe; y un
conjunto de sentencias encerrado entre llaves formando el cuerpo.
Tipo_dato_a_devolver nombre función(Tipo1 param1, ..., TipoN paramN)
{
Cuerpo
}
Tipo_dato_a_devolver: es el tipo de datos del valor que devuelve la función. Si no se especifica
ninguno, C asume que la función devuelve un valor de tipo entero (int).

Nombre función: identificador que se usará posteriormente para llamar a la función desde
cualquier punto del programa.
Tipo param: tipo y nombre de cada uno de los parámetros que recibe la función. Se especifican
entre paréntesis y separados por comas. Algunas funciones pueden no recibir parámetros
(void).
Los parámetros de la declaración se denominan parámetros formales, ya que representan los
nombres con que referirse dentro de la función a los datos que se transfieren a ésta desde la
parte del programa que hace la llamada.
Cuerpo: conjunto de declaración de variables y sentencias de ejecución necesarias para la
realización de la tarea especificada por la función. Debe incluir una o más sentencias return
para devolver un valor al punto de llamada.
Prototipos de una función.

Si en el punto del programa donde se va a realizar una llamada a una función, dicha función ya
ha sido definida previamente, entonces ya se conocen sus características (tipo del resultado,
número y tipo de los parámetros, etc.), por lo que la llamada puede realizarse sin problemas.
Sin embargo, si la función que se va a llamar se halla definida posteriormente al punto desde
donde se realiza la llamada, entonces debe crearse un prototipo de la función a la cual se
desea llamar. Dicho prototipo deberá colocarse antes del punto donde se haga la primera
llamada a la función, y consta únicamente de la cabecera de dicha función.
El prototipo de una función puede interpretarse como un aviso al compilador, para que cuando
encuentre una llamada a dicha función pueda conocer el tipo del resultado que devuelve y la
información sobre los parámetros que recibe.
A continuación se muestra el formato general de un prototipo, que corresponde a la cabecera
de la función seguida de un punto y coma:
Tipo nombre_función (Tipo1 param1, ..., TipoN paramN);
La utilización de prototipos de funciones no es obligatoria en C. Sin embargo, es aconsejable,
ya que facilitan la comprobación y detección de errores entre las llamadas a funciones y las
definiciones correspondientes.
Llamada a una función.

Finalmente, la llamada a una función se realiza con el nombre de la misma y una lista de
parámetros (si es que los requiere) entre paréntesis los cuales serán los que se transferirán a
la función. El número y tipo de los parámetros empleados en la llamada a la función debe
coincidir con el número y tipo de los parámetros formales de la definición o prototipo.
Adicionalmente, si la función devuelve algún valor (es decir, no es de tipo void) la llamada a la
función debe estar incluida en una expresión que recoja el valor devuelto.
Los datos empleados en la llamada a una función reciben el nombre de parámetros reales, ya
que se refieren a la información que se transfiere a la función para que ésta se ejecute. Como
veremos más adelante, los identificadores de los parámetros formales son locales a la función,
en el sentido de que no son reconocidos desde fuera de ésta. Por tanto, los nombres de los
parámetros formales no tienen por qué coincidir con los nombres de las variables usadas como
parámetros reales en el momento de la llamada.
Ejemplo:
En el siguiente programa mostraremos un aplicación sencilla de la utilidad de las funciones. En
este tendremos una función llamada “superficie” a la cual se le pasan dos valores enteros y

devuelve un valor tipo flotante que representa la superficie de un triangulo cuya base y altura
fueron pasadas a la función desde el lugar en donde esta fue llamada.
Programa:
#include <iostream>
#include <stdlib.h>
float superficie (int num1, int num2); /*Prototipo. Fuera del programa
principal y con punto y coma
al finalizar*/
int main() /*Inicio del programa principal*/
{
int a,b; /*Variables locales del programa principal*/
float d; /*que no tienen injerencia en la función superficie*/
printf("Introduzca el valor de la base: ");
scanf("%d",&a);
printf("Introduzca el valor de la altura: ");
scanf("%d",&b);
d=superficie(a,b); /*Llamada a la función "superficie" con el paso
de los valores de "a" y "b"*/
printf("\nbase = %d"
"\naltura = %d"
"\nsuperficie del triangulo = %f",a,b,d);
d=superficie(3,5); /*Nueva llamada a la función "superficie" con el paso
de los valores "3" y "5"*/
printf("\n\nLa superficie de un triangulo de 3*5 es %3.2f",d);
printf("\n\n");
system("PAUSE");
return 0;
}
float superficie (int base, int altura)/*Definición función "superficie" */
{
float x;/*Variable local de la función, no sirve en el programa principal */
x=(base*altura);
x=x/2;
return(x); /*Retorno al programa principal con el valor obtenido en "x" */
}
Resultado:
Introduzca el valor de la base: 3
Introduzca el valor de la altura: 9
base = 3
altura = 9
superficie del triangulo = 13.500000
La superficie de un triangulo de 3*5 es 7.50

CONEXIÓN Y PROGRAMACIÓN DEL PUERTO PARALELO.

Las comunicaciones en paralelo se realizan mediante la transferencia simultánea de todos los
bits que constituyen el dato (byte o palabra). Presentan la ventaja de que la transmisión puede
ser más rápida.
Sin embargo, las comunicaciones en paralelo no pueden ser implementadas para grandes
distancias debido a que no es viable la conexión física de todas las líneas necesarias. Las
comunicaciones en paralelo propiamente dichas no han sido normalizadas, lo que sí se
reconoce es la norma Centronic, para la conexión del PC a la impresora, mediante el envío
simultáneo de 8 bits de datos (un byte), además de un conjunto de líneas de protocolo
(handshake o intercambio). La operación más frecuente en la que interviene el puerto paralelo
del PC es en el envío de datos a la impresora.
Los antiguos circuitos integrados que se incluían en las tarjetas de interfase del puerto paralelo
no permitían la recepción de datos, sólo estaban diseñados para el envío de información al
exterior. Las versiones recientes de estas tarjetas de interfase de puertos paralelo sí permiten
la recepción de datos y dan la posibilidad, por ejemplo, de intercambiar información entre la PC
y un dispositivo externo a través del puerto paralelo, siempre que se utilice el software
adecuado.
La norma Centronics hace referencia a las características de la conexión en la interfase de
puerto paralelo y una impresora. Las líneas son latcheadas, esto es, mantienen siempre el
último valor establecido en ellas mientras no se cambien expresamente y los niveles de tensión
y de corriente coinciden con los niveles de la lógica TTL, cuyos valores típicos son:
• Tensión de nivel alto: 5 V.
• Tensión de nivel bajo: 0 v.
• Intensidad de salida máxima: 2.6 mA.
• Intensidad de entrada máxima: 24 mA.
La norma Centronics establece el nombre y las características de 36 líneas eléctricas para la
conexión entre el PC y la impresora. En realidad, para la transferencia de las señales de datos
y de control a través de la tarjeta de interfase paralelo sólo se requieren 18 líneas, las restantes
son líneas de masa que se enrollan alrededor de los cables de señal para proporcionarles
apantallamiento y protección contra interferencias. Por esto, las citadas tarjetas suelen
incorporar un conector hembra DB-25, mientras que prácticamente todas las impresoras
incorporan un conector hembra tipo Centronics macho de 36 pines.
Los cables comerciales para la conexión paralelo entre el PC y la impresora tienen una longitud
de 2 metros, aunque pueden ser mayores, no es recomendable que tengan una longitud
superior a 5 metros si se desea una conexión fiable y sin interferencias.
El puerto paralelo en un PC
Todos los ordenadores tipo PC están equipados, al menos, con una tarjeta de interfase
paralelo. La BIOS almacena el número de interfaces de puertos paralelo que se hayan
instalado en el equipo. La dirección de entrada/salida de cada uno de los puertos paralelo y el
número de puertos instalados en una PC se muestra en la pantalla inicial de arranque del
equipo, y es frecuente, que las direcciones de los dos primeros puertos paralelo sean las
siguientes:
• LPT1 = 0x378 Hexadecimal.
• LPT2 = 0x278 Hexadecimal.

Las tarjetas del puerto paralelo tienen una estructura muy simple; consta de tres registros:
• Registro de Datos (Data).
• Registro de Control (Control).
• Registro de Estado (Status).
Todas las señales que intervienen en el puerto tienen asociado un bit en uno de esos registros,
de acuerdo con las funciones asignadas a cada línea en particular.
El Registro de Datos.
Es de tipo latch de 8 bits, que puede ser leído y escrito desde el procesador. Es el registro
donde el procesador, en operaciones de salida (OUT), pone el dato que se quiere enviar a la
impresora y su dirección coincide con la dirección base del puerto paralelo (0x378 en LPT1).
Registro de Datos (D)

D7 D6 D5 D4 D3 D2 D1 D0
Invertido por
No No No No No No No No
Hardware
Pines en DB 25
2 3 4 5 6 7 8 9
hembra
El Registro de Estado.
El registro de estado indica la situación actual de la impresora conectada al puerto, de acuerdo
con los niveles de tensión que tengan las líneas ACK, BSY, PAP y OFON, lo que permite
controlar el comportamiento de la impresora.
Se trata de un registro de entrada (Lectura) de información, su dirección se obtiene sumando 1
a la dirección base del puerto (0x379 en LPT1).
Registro de Estado (S)

S7 S6 S5 S4 S3 S2 S1 S0
BSY /ACK PAP OFON /ERR X X X
Invertido por
Si No No No No
Hardware
Pines en DB 25
11 10 12 13 15
hembra
El símbolo «/» delante del nombre del bit indica que es activo a nivel bajo.
Pero el bit S7 del registro de estado (BSY ) es invertido por el hardware y, por tanto, la línea
tiene un nivel complementado al que aparece en ese bit.
El significado que tienen los bits de este registro es el siguiente:
Si el bit S7 (BSY-Busy) está a 0, significa que la impresora está ocupada (buffer de impresión
lleno, procesando información, pendiente de inicializar, etc.).
El bit S6 (/ACK-Acknoledge) indica que se ha producido una transferencia correcta: cuando del
puerto paralelo se transfiere un byte a la impresora, la impresora activa la línea ACK de
reconocimiento del carácter y, como consecuencia, el bit ACK del registro de estado pasa a
nivel bajo; cuando el bit ACK está a nivel alto, significa que la impresora está ocupada y no se
pueden realizar envíos.

El bit S5 (PAP-Paper) si está a 1, señala que la impresora no dispone de papel.

El bit S4 (OFON-Line Off) indica cuando está a 1, que la impresora no está en línea.
El bit S3 (ERR) si está a 0, indica que se ha producido un error de impresora (mal
funcionamiento, falta de papel, impresora fuera de línea).
Los bits 0,1 y 2 no se utilizan.
El Registro de Control.
El registro de control permite controlar las transferencias de información con la impresora,
puede ser escrito y leído desde el microprocesador. Es un registro de entrada/salida cuya
dirección se obtiene sumando 2 a la dirección base del puerto (0x37A en LPT1).
Registro de Control (C)

C7 C6 C5 C4 C3 C2 C1 C0
X X X IRQ DSL /INI ALF STR
Invertido por
Si No Si Si
Hardware
Pines en DB 25
17 16 14 1
hembra
El símbolo «/» delante del nombre del bit indica que es activo a nivel bajo.
Los bits STR, ALF y DSL del registro de control son invertidos por el hardware con relación a
las líneas correspondientes al cable de conexión, por lo que el nivel de los bits C0, C1 y C3 del
registro de control son complementados con relación a las líneas correspondientes.
El significado que tienen los bits de este registro es el siguiente:
El bit C4 (Interrupt request-IRQ) es el que permite controlar la generación de interrupciones de
tipo hardware desde el puerto paralelo. Si este bit está a 1, el interfase paralelo puede generar
la petición de interrupción IRQ7 (en LPT1), que se corresponden con las interrupción 0x0Fh
respectivamente del procesador 80X86. Esta petición de interrupción se produce cuando se da
una transición alto a bajo en la línea ACK.
El bit C3 (DSL). La mayoría de las impresoras paralelo IBM-compatibles, no utilizan esta línea y
son activadas con un pulsador de on-line.
El bit C2 (INI) produce una inicialización de la impresora (es poco utilizado).
El bit C1 (ALF). Si está a nivel alto, la impresora produce automáticamente un cambio de línea
(LF) cada vez que recibe un retorno de carro (CR).
El bit C0 (STR). Controla la línea que permite validar el dato existente en el registro de datos.
La puesta a 1 del bit STR genera un impulso corto que indica a la impresora que el carácter del
registro de datos es válido y debe ser aceptado. Así pues, cada vez que se precise enviar un
carácter, no basta con ponerlo en el registro de datos, sino que hay que hacer un reset en el bit
STR del registro de control y validar el dato volviendo a poner un 1 en ese bit.
Los bits C5, C6 y C7 no se utilizan.

Asignación de pines en el conector DB25 Hembra del puerto paralelo.
Numero de
pin en el Dirección Invertida
conector Señal Registro por
DB25 IN / OUT Hardware
Hembra
1 /STR IN / OUT Control SI
2 Data 0 OUT Datos
3 Data 1 OUT Datos
4 Data 2 OUT Datos
5 Data 3 OUT Datos
6 Data 4 OUT Datos
7 Data 5 OUT Datos
8 Data 6 OUT Datos
9 Data 7 OUT Datos
10 /ACK IN Estado
11 BSY IN Estado SI
12 PAP IN Estado
13 OFON IN Estado
14 /ALF IN / OUT Control SI
15 /ERR IN Estado
16 /INI IN / OUT Control
17 /DSL IN / OUT Control SI
18-25 GROUND GND

Entradas y salidas por el puerto paralelo.

Al hablar de operaciones de entrada y salida por el puerto paralelo no debe olvidarse que,
inicialmente, este elemento se desarrolló de acuerdo con el estándar Centronics con el fin, casi
exclusivo, de que el PC pudiese enviar datos en paralelo a la impresora conectada, no se
pensó en la posibilidad inversa, o sea, que el PC pudiese recibir datos a través de ese puerto.
Las operaciones de entrada y salida de información a través del puerto paralelo en el PC las
realizaremos gestionando el puerto paralelo en el nivel de registros, es decir, programando
directamente los circuitos integrados o chips que constituyen la tarjeta de interfase, lo cual
permitirá aprovechar al máximo todas las posibilidades que ofrezca realmente el hardware de
la tarjeta de interfase.
Características E/S.
Cuando usamos el puerto paralelo para otro cometido distinto al original, solo podemos hablar
de:
12 líneas de salida de información desde el ordenador:
• pines del 2 al 9. Registro de Datos.
• pines 1,14, 16 y 17. Registro de Control.
15 líneas de entrada al mismo:
• pines 2-9. Registro de Datos.
• pines 10, 11, 12,13 y 15. Registro de Estado
Esto hace del puerto paralelo una interfase de comunicación con el exterior bastante flexible.
El Registro de Estado es de sólo lectura. Cuando se lee este registro, lo que se recibe es el
estado lógico de los pines 10, 11, 12, 13 y 15 del conector DB-25 (el bit S7 contiene el
complemento del estado de la línea). Los tres bits de menor peso (SO-S2) no se utilizan y,
habitualmente, se encuentran a nivel alto.
El Registro de Control es parcialmente bidireccional. Cuando se escribe en los cuatro bits de
menor peso (C0 - C3) lo que se hace es establecer el nivel lógico de los pines C2 de forma
directa y C0, C1 y C3 de forma complementada. Los tres bits de mayor peso (C5, C6 y C7) no
se utilizan.
El Registro de Datos es de tipo latch de lectura y de escritura, de modo que cuando se realiza
una operación de escritura (OUT) el dato se carga en los bits correspondientes y las líneas
asociadas del conector tienden a alcanzar la tensión correspondiente a ese estado.
En algunas ocasiones las líneas de datos de la tarjeta de interfase paralelo (Centronics) son
bidireccionales, pero la etapa de salida se ha construido mediante buffers con transistores en
colector abierto. En este caso, el hecho de que las operaciones de entrada y salida se hagan
por las mismas líneas, condiciona notablemente el proceso de lectura, ya que con esa
configuración electrónica de las líneas de datos (D0-D7), los valores lógicos leídos dependerán
del nivel lógico presente en el registro y del valor de tensión en la línea (que no tienen por qué
coincidir) de acuerdo con lo mostrado en la siguiente tabla.

Nivel lógico leído en una

Nivel lógico de los bits en el Nivel de tensión en lo pines
operación de lectura del
registro de datos. del conector DB-25
puerto paralelo.
Bajo (0) Bajo (0) Bajo (0)
Bajo (0) Alto (1) Bajo (0)
Alto (1) Bajo (0) Bajo (0)
Alto (1) Alto (1) Alto (1)
A la vista de la tabla, lo que se deduce es que, si se va a realizar una operación de lectura

sobre el puerto paralelo, lo que se va a leer realmente es la operación AND lógica entre el nivel
lógico del registro y el nivel lógico de la línea, lo que implica que, si se desea realizar una
lectura real del estado de las líneas, deberá escribirse antes el dato 0xFF en el registro de
datos del puerto paralelo.
A continuación se da un ejemplo de cómo se programa el envío de datos a trabes del puerto
paralelo.

Programa:
/* El siguiente programa envía datos a trabes del puerto paralelo.
En primer momento envía unos a todo el bus de datos encendiendo
todos los LED por 1 seg. Luego envia ceros a todo el bus de datos
apagando todos los LED por 1 seg.
Luego comienza una secuencia de encendido de los LED´s uno a uno
en forma secuencial y en orden ascendente y descendente, generando
en los LED´s el efecto conocido como el del auto fantástico*/
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <C:\Dev-Cpp\io\io.cpp> // incluido en io.zip
#define Data 0x0378 // DATA
#define Status Data+1 // STATUS
#define Conrol Data+2 // CONTROL
{int i;
LoadIODLL(); // inicializar io.dll <io.cpp>
PortOut(Data,0xFF);// Envía UNOS (LEDS ON)
Sleep(1000); // Genera un retardo de 1000 ms (1 Seg)
_outp(0x378,0x00); // Envía CEROS (LEDS OFF)
Sleep(1000); // Genera un retardo de 1000 ms (1 Seg)
for (i=0;i<10;i++)
{_outp(0x378,0x01);
Sleep(100);
_outp(0x378,0x02);
Sleep(100);
_outp(0x378,0x04);
Sleep(100);
_outp(0x378,0x08);
Sleep(100);
_outp(0x378,0x10);
Sleep(100);
_outp(0x378,0x20);
Sleep(100);
_outp(0x378,0x40);
Sleep(100);
_outp(0x378,0x80);
Sleep(100);
_outp(0x378,0x40);
Sleep(100);
_outp(0x378,0x20);
Sleep(100);
_outp(0x378,0x10);
Sleep(100);
_outp(0x378,0x08);
Sleep(100);
_outp(0x378,0x04);
Sleep(100);
_outp(0x378,0x02);
Sleep(100);
}
_outp(0x378,0x00);
system("PAUSE");
return 0;
}

APÉNDICE A - TABLA DE CARACTERES ASCII

APÉNDICE B – MÉTODOS DE ORDENAMIENTO Y BÚSQUEDA.
Ordenamiento.
Uno de los procedimientos más comunes y útiles en el procesamiento de datos, es la
clasificación u ordenación de los mismos. Se considera ordenar al proceso de reorganizar un
conjunto dado de objetos en una secuencia determinada. Cuando se analiza un método de
ordenación, hay que determinar cuántas comparaciones e intercambios se realizan para el
caso más favorable, para el caso medio y para el caso más desfavorable.
La colocación en orden de una lista de valores se llama ordenación. Por ejemplo, se podría
disponer una lista de valores numéricos en orden ascendente o descendente, o bien una lista
de nombres en orden alfabético. La localización de un elemento de una lista se llama
búsqueda.
Tal operación se puede hacer de manera más eficiente después de que la lista ha sido
ordenada. Existen varios métodos para ordenamiento, clasificados en tres formas:
• Intercambio.
• Selección.
• Inserción.
En cada familia se distinguen dos versiones: un método simple y directo, fácil de comprender
pero de escasa eficiencia respecto al tiempo de ejecución, y un método rápido, más sofisticado
en su ejecución por la complejidad de las operaciones a realizar, pero mucho más eficiente en
cuanto a tiempo de ejecución. En general, para arreglos con pocos elementos, los métodos
directos son más eficientes (menor tiempo de ejecución) mientras que para grandes cantidades
de datos se deben emplear los llamados métodos rápidos.
Método de la burbuja.
El método de intercambio o método de la burbuja se basa en comparar los elementos del
arreglo e intercambiarlos si su posición actual o inicial es contraria inversa a la deseada.
Pertenece a este método el conocido método de la burbuja clasificado como intercambio
directo. Aunque no es muy eficiente para ordenar listas grandes, es fácil de entender y muy
adecuado para ordenar una pequeña lista de unos 100 elementos o menos.
Una pasada por la ordenación de burbujeo consiste en un recorrido completo a través del
arreglo, en el que se comparan los contenidos de las casillas adyacentes, y se cambian si no
están en orden. La ordenación por burbujeo completa consiste en una serie de pasadas
("burbujeo") que termina con una en la que ya no se hacen cambios porque todo está en orden.
Ejemplo: Supóngase que están almacenados cuatro números en un arreglo con casillas de
memoria de x[1] a x[4]. Se desea disponer esos números en orden creciente. La primera
pasada de la ordenación por burbujeo haría lo siguiente:
Comparar el contenido de x[1] con el de x[2]; si x[1] contiene el mayor de los números, se
intercambian sus contenidos. Comparar el contenido de x[2] con el de x[3]; e intercambiarlos si
fuera necesario. Comparar el contenido de x[3] con el de x[4]; e intercambiarlos si fuera
necesario.
Al final de la primera pasada, el mayor de los números estará en x[4].

El método de ordenamiento por el método de la burbuja se llama así porque los números
pequeños ascienden como burbujas hasta la parte superior, mientras que los mayores se
hunden y caen hacia el fondo. Está garantizado que cada pasada pone el siguiente número
más grande en su lugar, aunque pueden colocarse más de ellos en su lugar por casualidad.

Programa:
#include <stdio.h>
#include <stdlib.h>
{ int i,j;
float numero[10],auxiliar;
printf("Programa ejemplo del metodo de ordenamiento de la burbuja");
printf("\n\nIngrese 10 valores que seran ordenados de menor a
mayor\n");
for(i=0;i<10;i++)
{printf("Numero %d: ",i+1);
scanf("%f",&numero[i]);
}
for(j=0;j<9;j++)
{for(i=0;i<9-j;i++)
{if(numero[i]>numero[i+1])
{auxiliar=numero[i+1];
numero[i+1]=numero[i];
numero[i]=auxiliar;
}
}
}
printf("\n\nLos numeros ingresados y ordenados de");
printf(" menor a mayor son:\n");
for(i=0;i<10;i++)
printf("%f\n",numero[i]);
system("PAUSE");
return 0;
}
Resultado:
Programa ejemplo del metodo de ordenamiento de la burbuja
Ingrese 10 valores que seran ordenados de menor a mayor
Numero 1: 1.25
Numero 2: 10.25
Numero 3: 159
Numero 4: 999
Numero 5: 2145
Numero 6: 3.012
Numero 7: 3.1415
Numero 8: 1978
Numero 9: 0.017
Numero 10: 46.58
Los numeros ingresados y ordenados de menor a mayor son:
2145.000000
1978.000000
999.000000
159.000000
46.580002
10.250000
3.141500
3.012000
1.250000
0.017000

APÉNDICE C – INTERFASE PARA PUERTO PARALELO.
Introducción.
El siguiente circuito es propuesto como una interfase para conectar el puerto paralelo al mundo
exterior | sea para generar señales de control hacia el exterior como para introducir señales
tomadas por algún transductor digital.
Descripción.
Entre las señales de salida que el puerto paralelo nos proporciona, tenemos los 8 bits del
registro de datos, los cuales se encuentran en los pines 2 al 9 en el conector DB25 (J2) y que
en el circuito son conectados al Octal BUS Transceiver (IC1-74HC245) que se encarga de
adaptar las señales mediante buffers; para que estén disponibles en nuestra placa con niveles
correctos para la tecnología TTL. Las señales a la salida del IC1 se encuentran disponibles
directamente en el conector J3 para su uso en aplicaciones con niveles lógicos TTL.
Además estas señales ingresan en un array de transistores Darlington (IC3-ULN2803) que se
encarga de proporcionar niveles lógicos mara manejo de potencia; con salidas de 12V/500mA
que tendremos disponibles en los conectores J4 y J5.
Los LED´s (D1-D8) con sus respectivas resistencias limitadoras de corriente (R1-R8) se utilizan
para proporcionarle al usuario una indicación visual permanente del nivel lógico en las salidas,
de este modo, cada LED permanecerá encendido mientras tengamos un nivel alto (1 con lógica
positiva = 5V) y se apagará cuando tengamos un nivel bajo (0 con lógica positiva = GND).
Las señales que se ingresan a través del puerto paralelo se realizan mediante los pines
10,12,13 y 15 del conector DB25 (J2). Estas señales provenientes del mundo físico exterior
deben ser previamente transformadas con un transductor de forma de proporcionarle a nuestra
interfase niveles lógicos TTL compatible. Estas señales ingresan a través del conector J6 hacia
el Octal BUS Transceiver (IC2-74HC245) que se encarga de adaptar los niveles logicos TTL
antes de enviarlas hacia el puerto paralelo.
La fuente de alimentación esta formada por el regulador serie de voltaje (IC4-LM7805) y los
capacitares de filtrado C1, C2 y C3. La entrada será a través del conector J1 con niveles de
tensión continua entre los 7V – 24V capas de proporcionar un consumo de 100 mA.
Lista de materiales:
R1-R8 1KΩ - 1/4W.
R9-R12 10KΩ - 1/4W
C1 100 μF/35V
C2, C3 100 ηF cerámico.
D1-D8 Diodo LED rojo de 35mm.
IC1, IC2 74HC245
IC3 ULN2803
IC4 LM7805
J1 conector dos terminales.
J2 conector DB25 macho – 90° p/soldar en plaqueta.
J3 Tira de pines paralelos rectos dobles - 4x2.
J4 – J6 conector cuatro terminales.

Diagrama electrónico:
Power Supply 12 Vdc VCC
J1 IC4 7805
2 1 3
12 Vdc VI VO
1
GND
GND
C1 C2 C3
100p 100p
2
100uF/35V
TTL Output
8
7
6
5
GND
J3
J2 12 Vdc
1
2
3
4
1 Higt Power Output
14
2 12 Vdc / 500 mA
15
3
IC3 J4
IC1 COM
10
16 1
2 18 1 18 Output 0
4 A0 B0 1B 1C 2
3 17 2 17 Output 1
17 A1 B1 2B 2C 3
4 16 3 16 Output 2
5 A2 B2 3B 3C 4
5 15 4 15 Output 3
18 A3 B3 4B 4C
6 14 5 14
6 A4 B4 5B 5C 1
7 13 6 13 Output 4
19 A5 B5 6B 6C 2
8 12 7 12 Output 5
7 A6 B6 7B 7C 3
9 11 8 11 Output 6
20 A7 B7 8B 8C 4
Output 7
8 VCC
19 ULN2803A
21 CE
9
1
AB/BA
J5
22
74HC245
10
VCC D1 D3 D5 D7
23
11 GND
24
12
25
13
10k 10k 10k 10k D2 D4 D6 D8
DB25 Macho IC2 R9 R10 R11 R12
2 18 1k 1k 1k 1k 1k 1k 1k 1k
A0 B0
3 17
A1 B1
4 16
5
A2 B2
15
R1 R2 R3 R4 R5 R6 R7 R8
A3 B3
6 14
A4 B4
7 13
A5 B5
8 12
A6 B6
9 11 GND
A7 B7
GND
19
CE Input Signal
1
AB/BA
J6
74HC245 4
Input 0
3
Input 1
2
GND GND Input 2
1
Input 3
Placa PCB:
Vista Componentes Vista Soldadura

Este texto no pretende “sustituir a un profesor”, sino servir de apoyo para que los alumnos no
pierdan tiempo en tomar apuntes. Es trabajo del profesor aclarar las dudas que surjan y
proponer muchos más ejercicios que los que figuran aquí.
Este texto ha sido escrito por el Ingeniero Avramovich, Javier Alejandro. Si quiere conseguir la
última versión, o sugerir modificaciones por favor envíe un mail a:
ing.avramovich@hotmail.com
Este texto es de distribución gratuita. Se puede distribuir a otras personas libremente, siempre
y cuando no se modifique su contenido parcial o total.
Este texto se distribuye "tal cual", sin garantía de ningún tipo, implícita ni explícita. Aun así, mi
intención es que resulte útil, así que le rogaría que me comunique cualquier error que
encuentre.
Para cualquier sugerencia, no dude en contactarme.
El autor

Apunte Herramientas Informaticas

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apunte Herramientas Informaticas

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD TECNOLÓGICA

Ing. Centeno, Carlos

Ing. Prof. Avramovich, Javier A. 3

Sistema binario ....................................................................................................................... 28

4 Ing. Prof. Avramovich, Javier A.

Diagrama electrónico: ............................................................................................................. 79

Ing. Prof. Avramovich, Javier A. 5

6 Ing. Prof. Avramovich, Javier A.

Arquitectura de una computadora

Ing. Prof. Avramovich, Javier A. 7

8 Ing. Prof. Avramovich, Javier A.

- Copia los contenidos de la posición de memoria 123.

Entrada de datos o información

Microprocesador Memoria RAM

Almacenamiento Salida directa

Ing. Prof. Avramovich, Javier A. 9

COMPONENTES BÁSICOS DEL HARDWARE.

10 Ing. Prof. Avramovich, Javier A.

Ing. Prof. Avramovich, Javier A. 11

Dispositivos de crecimiento (Slots).

12 Ing. Prof. Avramovich, Javier A.

Ing. Prof. Avramovich, Javier A. 13

Los periféricos de comunicación más habituales son:

Otros conceptos y curiosidades

14 Ing. Prof. Avramovich, Javier A.

TIPOLOGÍA DEL SOFTWARE

LOS SISTEMAS OPERATIVOS.

Ing. Prof. Avramovich, Javier A. 15

Lenguaje de bajo nivel (ensambladores)

16 Ing. Prof. Avramovich, Javier A.

Programa fuente Programa en

Lenguaje de alto nivel.

Características de los lenguajes de programación:

FORMAS DEL SOFTWARE

Ing. Prof. Avramovich, Javier A. 17

Código o Programa Compilado Código o Programa Linkeado Código o Programa

EL PROCESO DE CREACIÓN DE SOFTWARE

18 Ing. Prof. Avramovich, Javier A.

contexto) no es inmediatamente ejecutado en una computadora. La opción más común es

Programación e ingeniería del software

Ing. Prof. Avramovich, Javier A. 19

Corrección: un programa es correcto si hace lo que debe hacer. Para determinar si un

20 Ing. Prof. Avramovich, Javier A.

Nombre, valor de retorno y argumentos de una función

Ing. Prof. Avramovich, Javier A. 21

22 Ing. Prof. Avramovich, Javier A.

La función principal o función main()

Palabras claves del C

Ing. Prof. Avramovich, Javier A. 23

24 Ing. Prof. Avramovich, Javier A.

Ing. Prof. Avramovich, Javier A. 25

26 Ing. Prof. Avramovich, Javier A.

UNIDADES DE MEDIDA EMPLEADAS EN INFORMÁTICA

Los bytes, Kilobytes, Megabytes

Ing. Prof. Avramovich, Javier A. 27

28 Ing. Prof. Avramovich, Javier A.

Ing. Prof. Avramovich, Javier A. 29

12 (decimal) = C (hexadecimal) 14 (decimal) = E (hexadecimal)

30 Ing. Prof. Avramovich, Javier A.

Ing. Prof. Avramovich, Javier A. 31

Las estructuras que incorpora el C basadas en la programación estructurada son:

A partir de ahora se explicara la simbología en el diagrama de flujo, la instrucción en C y un

32 Ing. Prof. Avramovich, Javier A.

“Aquí se escribe el texto que saldrá por pantalla”