Manual de Hardware - Historia de Los Sistemas Informaticos PDF

SISTEMAS INFORMÁTICOS
2º INGENIERÍA QUÍMICA
Profesores Departamento Curso Académico

F. Pérez Ingeniería de Sistemas y Automática 2003-04
Isidro Calvo
TITULACIÓN: INGENIERÍA QUÍMICA
ASIGNATURA: SISTEMAS INFORMÁTICOS
AÑO ACADÉMICO: 2º
CREDITOS: 3Ty3P
AÑO ACADÉMICO: 2003-2004
OBJETIVOS:
El objetivo de la asignatura es introducir a los alumnos en el mundo de la
informática más allá del punto de vista del usuario. Para ello se imparten conocimientos
avanzados sobre arquitectura de computadores, sistemas operativos y lenguajes de
programación.
TEMARIO TEÓRICO:
Tema 1. Introducción a la informática.
Conceptos básicos. Origen y evolución de los sistemas de cálculo. Ordenadores
personales. Estudio comparativo. Sistemas inteligentes. El PC. Memorias.
Tema 2. Estructura general de un sistema de computación.

Descripción general. Elementos de almacenamiento. Unidad de control. Buses.
Estructura general. Fases de ejecución de instrucciones.
Tema 3. Codificación de la información.

Conceptos generales. Codificación. Sistemas de numeración. Representación
numérica. Códigos de alfanuméricos. Detección y corrección de errores.
Tema 4. Fundamentos de sistemas operativos.

Elementos de un sistema de computación. Tipos de sistemas operativos.
Funcionamiento de los sistemas de computación. Arquitectura de los sistemas
operativos. Elementos de los sistemas operativos.
Tema 5. Lenguajes de programación.

Objetivos de la programación. Tipos de lenguajes. Herramientas de
programación. Desarrollo de programas.
Tema 6. Programación estructurada.

Elementos del lenguaje. Estructura general de un programa. Comentarios. Pasos
de programación. Funciones básicas.
Tema 7. Elementos base de programación.

Identificadores. Palabras reservadas. Constantes. Operadores. Separadores.
Comentarios.
Tema 8. Tipos de datos simples.
Tipos simples: Enteros, reales y caracteres. Variables y constantes. Expresiones
y sentencia de asignación. Conversiones. Operaciones de lectura y escritura..
Tema 9. Operadores.
Operadores Aritméticos. Incremento y decremento. Operadores de relación.
Operadores de comparación. Operadores lógicos. Operadores de acceso a los
objetos. Dirección de un objeto. Tipos de direccionamiento. Conversión de tipos
de variables. Prioridad de operadores. Evaluación de expresiones.
Tema 10. Instrucciones.

Instrucciones simples y compuestas. Instrucciones de condicionales. Instrucciones
repetitivas. Estructuras anidadas.
Tema 11. Subprogramas

Concepto de subprograma. Tiempo de vida y visibilidad de las variables. Paso
de parámetros por valor y por referencia. Efectos laterales.
Tema 12. Funciones

Definición, declaración y llamada. Transmisión de información entre funciones.
La función principal.
Tema 13. Tipos estructurados

Arrays unidimensionales y multidimensionales. Cadenas de caracteres. Funciones
para el tratamiento de cadenas de caracteres. Estructuras. Estructuras anidadas.
Punteros.
Tema 14. Archivos

Ficheros binarios y de texto. Entrada y salida estándar. Funciones para el manejo
de ficheros.
PRÁCTICAS:
- Sesiones 1–2: Arquitectura del PC.
- Sesiones 3–4: Entorno de programación.
- Sesiones 5–12: Programación en C.
- Sesiones 13–15: Sistema operativo Linux.
Temario
• Arquitectura del PC
• Estructura de Sistemas de Computación
• Sistemas Operativos - Linux
• Lenguajes de Programación
• Programación en C
• Estructura de Programa
• Elementos del Lenguaje
• Sentencias de Control
• Modularidad
• Tipos de Datos
• Ficheros
• Sistemas Básicos de Comunicación
Bibliografía
Sistemas Operativos
Silberschatz, Galbin
Ed. Pearson, Addison Wesley Longman
Linux - Edición Especial

Tackett, Burnett
Ed. Prentice Hall
Fundamentos de Programación, Algoritmos y Estructura de Datos

Joyanes
Ed. McGraw Hill
Programación Estructurada en C
Antonakos, Mansfield
Ed. Prentice Hall
Programación en C
Joyanes, Zahonero
Ed. McGraw Hill
Curso de Programación C/C++

Ceballos
Ed. RA-MA
SISTEMAS INFORMÁTICOS
MÉTODO DE CALIFICACIÓN
¾ Examen Final – Obligatorio (80% de la nota final). Nota mínima de aprobado 5.

Calificación por conocimiento demostrado. Dos partes:
9 Teórica: Preguntas teóricas, modelo tipo test
9 Práctica: Desarrollo de un programa en C
¾ Laboratorio – Obligatorio (20% de la nota final). Nota mínima de aprobado 5. La

nota se mantiene durante el año posterior a la calificación. Dos tipos de calificación:
9 Asistencia + trabajos: Asistencia semanal y aprovechamiento. Entrega de
los trabajos que se pidan. Disponibilidad de un disco con todas las prácticas
desarrolladas.
9 Examen: Uno por convocatoria
Introducción a los
Sistemas Computación
Sistemas Informáticos
Fede Pérez
Índice
TEMA - Introducción a los Sistemas de Computación
1. - Conceptos Básicos
2. - Origen y Evolución de los Sistemas de Cálculo
2.1 – Abaco
2.2 – Calculadoras Mecánicas
2.3 – Las Primeras Computadoras Mark I | ENIAC | ABC
2.4 – Las Calculadoras de Von Neuman
3. - Generaciones de Ordenadores
4. - El Ordenador Personal
5. - Razones del Éxito de los Computadores
6. – Estudio Comparativo de la Evolución de los Computadores
7. – Futuro de los Ordenadores
Definiciones
Informática: trata de la adquisición, representación, tratamiento y transmisión de la
información.
(Según la Real Academia Española de la Lengua) Es el conjunto de conocimientos
científicos y técnicos para hacer posible el tratamiento automático de la
información por medio de computadoras electrónicas
Computadora u Ordenador: Es una máquina electrónica capaz de aceptar unos

datos de entrada, efectuar con ellos una operaciones aritméticas y lógicas, y
proporcionar la información resultante a través de un medio de salida; todo ello sin
intervención de un operador humano y bajo el control de un programa de
instrucciones previamente almacenado en la propia computadora
Calculadora: (acepción actual) Es una máquina capaz de efectuar operaciones

aritméticas bajo el control directo del usuario
Datos: Son conjuntos de símbolos utilizados para expresar o representar un valor numérico,
un hecho, un objeto o una idea, codificada en la forma adecuada para ser objeto de
tratamiento por medio de una computadora
Información: Datos tratados y organizados, con significado desde el punto de vista del
usuario
DATOS + INTERPRETACION = INFORMACION UTIL
Hardware vs. Software

Hardware: Componentes físicos, dispositivos de estado sólido y similares, de un
ordenador
Software: Programas que dirigen el funcionamiento de un ordenador
Firmware: Ente intermedio entre el hardware y el software

Ordenadores Dedicados y de Propósito General
Ordenador de Propósito General: Puede ejecutar un amplio rango de

tareas de proceso de información
Ordenador Dedicado: Está diseñado para una tarea específica o para un rango
reducido de tareas
Evolución de los Sistemas de Calculo – Ábaco

Ábaco: Serie de alambres paralelos, sujetos por los extremos en un armazón
rectangular, sobre los que se pueden desplazar una serie de bolas o
fichas
TIPOS DE ÁBACOS
Origen Nombre Características
China suan pan Consta de 13 hileras de cuentas, divididas en dos partes por una varilla montada
transversalmente en el marco, en la parte superior cada hilera con 2 cuentas con un valor de 5
unidades cada una, y en la parte de abajo 5 cuentas, cada una con el valor de una unidad
Japón soroban Consta de 13 hileras de cuentas, divididas en dos partes, en la parte superior cada hilera con 1
cuenta con valor de 5 unidades cada una, y en la parte de abajo 4 cuentas, cada una con el valor
de una unidad
Roma ? Se utiliza piedra caliza o mármol que se deslizaban sobre ranuras de superficie plana, las
pequeñas piedras se les denominó con el nombre de calculi.
Rusia stchoty ?
Evolución – Calculadoras Mecánicas 1
La Calculadora de Sckickard
En 1623 Wilhelm Sckickard construye la
primera máquina de calcular
La Pascalina
1.642 Blaise Pascal. Conjunto de discos
dentados, cada uno de los cuales tiene 10
divisiones, que representaban un dígito. Es
capaz de realizar sumas y restas
La Calculadora Universal
1694 Gottfried W. Leibniz. Perfecciona la
máquina de Pascal añadiéndole la
multiplicación y división.
La Lógica Matemática
George Boole (1815-1864), es el fundador
de la teoría de la lógica matemática.

El Padre de la Computadora
Se considera a Charles Babbage (1791-
1871), como el padre de los sistemas
actuales de computación. A Charles
Babbage se le atribuye el desarrollo de dos
máquinas de cálculo:
La Máquina Diferencial: (1821) capaz de

calcular polinomios de sexto grado y tabular
mecánicamente hasta veinte cifras y ocho
decimales
La Máquina Analítica: (1833) sistema

mecánico precursor de la computadora del
siglo XX. Disponía de:
•Dispositivo de entrada/salida de datos (tarjetas
perforadas)
•Unidad de memoria
•Dispositivo de cálculo llamado "Mill" (Unidad
Aritmética)
•Mecanismo de barras y palancas que accionaba el
conjunto (Unidad de Control), conducido por un
programa codificado sobre tarjetas perforadas
La Máquina de Tabular
En 1890 Herman Hollerith (1860-1929),
inventó su máquina tabuladora que utilizaba
corriente eléctrica para detectar los agujeros
que estaban perforados y así hizo registrar
la información en tarjetas, y el tiempo total
del proceso se redujo. Sistema de
automatización del censo.
Evolución – Las Primeras Computadoras 1

La Computadora
Electromecánica
Z-1 (1935)
Konrad Zuse en Berlín desarrolló su computadora Z-1
Mark I Computer (ASCC) Automatic

Sequence Controller Calculator (1944)
Desde 1937 hasta 1944, IBM patrocinó el proyecto del
Dr. Howard H. Aiken, profesor de la universidad de
Harvard. En 1944 finalizó su objetivo con el nombre de
Mark I.
Evolución – Primer Bug

La Computadora Electrónica
ABC (Atanasoff Berry Computer)
(1936/37)
John Vicent Atanasoff y Clifford Berry. Principios de las
primeras computadoras.
ENIAC (Electronic Numerical Integrator

and Computer) (1946)
Construido en la universidad de Pennsylvania, por John
W. Mauchly y John Presper Eckert
Calculadoras de Von Neuman
John Von Neumann (1903-1957)
1.946 "First Draft of a Report on to Edvac“
Principios ordenadores del tipo Von Neumann:
•Concepto de numeración codificada
•Almacenamiento del programa en memoria
•Perfeccionamiento de la ruptura de secuencia
EDSAC (1.949)
M. Wikes, de la Universidad de Cambridge
UNIVAC (1.951)
Eckert y Mauchly, primera computadora adquirida con
fines lucrativos.
Babbage vs. Von Newman

Modelo de Programa
C.P.U.
Computadora
según
Babage Memoria
Datos Resultados
Entrada U.A. Salida
Modelo de C.P.U.
Computadora
según
Von Newman Memoria
Datos Resultados
Entrada U.A. Salida
Programa
Generaciones de Ordenadores 1
1ª Generación (1940-52)
9 Tecnología empleada: Válvulas de vacío
9 Uso: Científico y militar.
9 Programación: Modificando directamente los valores de los circuitos de la máquina. No
existían los lenguajes de programación, ni siquiera el ensamblador.
9 Ordenadores caros, debido a la corta vida de la válvulas de vacío y al gran calentamiento,
así como al gran consumo de energía eléctrica.
9 Ordenadores lentos.
9 Capacidad de almacenamiento muy pequeña.
9 Incapacidad de ejecutar más de una tarea a la vez.
Algunas de las realizaciones son: UNIVAC | EDSAC | EDVAC | ORDAC | ILLIAC |

MANIAC | JHONIAK | WEIZAK
9 Tecnología empleada: Transistor
9 Disponía ya de una programación previa, de un Sistema Operativo, capaz de interpretar
instrucciones escritas en lenguajes de programación como COBOL o FORTRAN.
9 Comienza el desarrollo de periféricos de E/S (impresoras) y los Lenguajes de alto nivel
(y el ensamblador).
9 El modo de trabajo era generalmente el sistema por lotes.
9 Aumento de la velocidad en el cálculo
9 Reducción de tamaño
9 Reducción del consumo a energía y potencia disipada
9 Tiempo de vida media del transistor superior a la válvula
9 Abaratamiento
Algunas de las realizaciones son: Sperry Rand 1207 | IBM 700 | IBM 1400 | 1700
9 Tecnología empleada: Circuito integrado (lámina de silicio embutida en plástico). Se
utilizan materiales semiconductores en lugar de los núcleos de ferrita en la construcción
de memorias.
9 Se mejoran los lenguajes de programación y empezaron a aparecer programas
comerciales, con lo que un usuario no tenía que programar sus aplicaciones.
9 Capacidad de multiprogramación, con lo cual los ordenadores son capaces de ejecutar
varias tareas al mismo tiempo.
9 Aumento en la velocidad de cálculo
9 Tamaño disminuye
Algunas de las realizaciones son: IBM System/360 | GE 600 | PDP-11
4ª Generación (1975-?)
9 Tecnología empleada: Circuitos de alta escala de integración. Microprocesadores.
9 Es el producto de una serie de avances tanto en el hardware, y su tecnología de
fabricación, como en el software y sus posibilidades de aplicación:
o Nuevas tecnologías de fabricación de semiconductores que conducen a velocidades de
transmisión cada vez mayores y mayor capacidad de almacenamiento.
o Aparición de paquetes software, que obedecen a nuevas concepciones y situaciones
específicas: bases de datos, diseño asistido, tratamiento de texto, ...
o Nuevas memorias de al almacenamiento: tecnologías Winchester, y burbujas magnética
o Aparición de los ordenadores personales
o Más lenguajes de alto nivel y herramientas informáticas.
o Desarrollo de periféricos inteligentes: descargan de trabajo a la CPU.
o Hacia mediados de los 80, comienza el desarrollo de redes de computadoras personales que
corren sistemas operativos en red y sistemas operativos distribuidos
5ª Generación (?)
9 Arquitectura diferente a la propuesta por Von Neumann
9 Ordenadores inferentes
9 Ordenadores de transputers
9 Ordenador óptico
9 Máquinas neuronales
9 Sistemas informáticos distribuidos
El Ordenador Personal
9 Años 70, primer microprocesador, el INTEL 4004, posibilidad de construcción de un
ordenador utilizable por un solo usuario
9 1977, S. Wozniak y S. Jobs, fundaron una empresa llamada Apple
9 1.981, IBM PC (Personal Computer)
9 Evolución tanto en el microprocesador utilizado (8088, 8086, 80286, 80386, 80486,
Pentium) y en el sistema operativo (UNIX para PC, el OS/2 de IBM y el Windows de
Microsoft)
9 Mediados de los 80, comienza el desarrollo de redes de computadoras personales
Estudio Comparativo de la Evolución de los
Computadores
Potencia
Tamaño
Precio
Tiempo
Arquitectura y Componentes del
PC
Fede Pérez
Índice
TEMA – Arquitectura y Componentes del PC
1. – Componentes Básicos
1.1 – Funcionalidad
1.2 – Emplazamiento
1.3 – Características más Importantes
2. – Evolución
4. - Conclusiones
El PC - Disposición
Minitorre Sobremesa
Chasis en disposición de Torre
Estructura Interna de un Microcomputador

La Placa Base (I)
Ö Elemento principal al que

se conectan los restantes
componentes y periféricos.
Ö Formatos
9 Baby AT
8 Conector grueso del teclado.
8 Dificultad al instalar tarjetas de
expansión largas.
8 Mantenimiento farragoso.
Esquema del formato Baby AT.
La Placa Base (II)
9 ATX
8 Mejora la flexibilidad,
integración y funcionalidad.
Formato ATX.
8 Reorganización de la
distribución de componentes.
8 Disminución de la longitud de
los cables, mejora de la
ventilación.
8 Conectores PS/2
8 USB
Componentes de la Placa Base
Componentes de la Placa Base

La Fuente de Alimentación
Ö Niveles de c.c. Ö Convierte la energía alterna

9 +/-12 V Amarillo. de la red a dos niveles de
continua.
9 +/-5 V Rojo.
9 GND Negro.
La Fuente de Alimentación - Conectores
Conectores ATX en Placa Base

Conectores ATX
Conectores en Y
Conectores P6
El Chipset
Ö Determina el rendimiento y características de la placa.

Ö Controla su modo de operación e integra todas sus funciones.
9 Velocidad del bus
9 Controlador de IRQ
9 Tipos de memoria
9 Tipo de CPU
9 Nº de CPUs
9 Características PnP
9 Puente PCI-ISA
9 Controlador de DMA
9 Tipo de caché L2
9 ...
La Memoria
Ö Memoria principal:
9 Más y mayores programas al
mismo tiempo.
9 SIMM (5V)-DIMM (3.3-5V), Nº
de contactos 30, 72, 168.
9 Bus de datos { bus de
memoria. Organización en
bancos.
Ö Memoria caché:
9 Acelera los procesos de la
CPU, almacén últimos datos
transferidos.
9 Emplazamiento sobre placa
o módulos COAST.
Módulo DIMM.
Papel de la memoria en un PC
Ö Al referirnos a “memoria”
generalmente nos referimos a la
memoria RAM.
Ö Un ordenador utiliza la memoria RAM

para guardar las instrucciones y los
datos temporales que se necesitan
para ejecutar las tareas. Esto permite
a la CPU del ordenador (unidad central
de proceso), acceder rápidamente a
las instrucciones de acceso y a los
datos almacenados en la memoria .
Ö Además de la RAM en un PC
encontramos otros muchos tipòs de
memoria
9 SDRAM (RAM)
9 ROM FLASH (BIOS)
9 SRAM (cache)
9 etc
Clasificación de la Memoria por Tipos
TIPOS MEMORIA
Volátiles No volátiles
FIFO RAM ROM
DINAMICA ESTATICA PROM Y EPROM

(DRAM)
EEPROM
VIDEO SISTEMA SRAM
FLASH
VRAM FPM MRAM
WRAM EDO
SGRAM SDRAM
SDRAM DDR
DDR-RAM RDRAM (RAMBUS)

BIOS – Pila
Ö Memoria ROM, EPROM,

FLASH que contiene las
rutinas necesarias para
arrancar el PC.
Ö Se apoya en una memoria
CMOS, alimentada por una
batería.
Ö Contiene el programa de
configuración del PC.
BIOS-Pila.
BIOS – Pantalla de Configuración

El Procesador (I)
Ö Es el chip más importante

de la placa base.
Ö Está formado por:
9 ALU -Unidad Aritmético
Lógica.
9 UC -Unidad Central.
9 Memoria Central (R.A.M)
8 Caché interna (L1).
8 Caché externa (L2). Pentium 4
El Procesador (II)
Ö Principales Características:
9 Velocidad.
9 Tipo de zócalo.
9 Memoria Caché.
9 Instrucciones Especiales.
9 Bus de comunicación.
9 Tecnología de fabricación.
Buses de Expansión (I)
Ö Al conectar una tarjeta a un bus de expansión, ésta

funciona como si estuviera directamente conectada al
procesador. Características de las principales:
Ö PCI Ö SCSI Ö AGP Ö ISA

9 Independiente de la CPU 9 E/S Inteligente 9 Apartado gráfico 9 1ª en aparecer
9 Controlador de bus 9 Necesita de otros buses 9 Color marrón 9 Color negro
9 Plug & Play 9 Direccionamiento lógico
9 Color crema 9 Hasta 15 dispositivos
Buses de Expansión (II)
Vesa Local Bus
PCI Bus
Periféricos Internos
Ö Dispositivos que se conectan a la placa base por

medio de los buses o ranuras de expansión.
Ö Los más comunes son:
9 Unidades de almacenamiento.
8 Disquetera
8 Disco duro
8 CD_ROM
8 DVD
8 Instalación de varios dispositivos
9 Tarjetas de vídeo
9 Tarjetas de sonido
El Disco Duro (I)

Ö Sistema de almacenamiento, en el se guardan los
archivos de los programas (SO,Word..)
El Disco Duro (II)
Instalación de Varios Disp. de Almacenamiento
Ö Las controladoras EIDE,

disponen de dos canales IDE
independientes, pudiendo
instalar hasta 4 dispositivos, 2
por canal.
9 1º->primario master.
9 2º->primario esclavo.
9 3º->secundario master.
9 4º->secundario esclavo.
8 El primario master arranca el
computador.
Ö Una controladora SCSI(las

más rápidas) se pueden
conectar hasta 7 dispositivos
o 15 si es WIDE SCSI.
Disquetera y CD-ROM
Ö DISQUETERA
9 Sólo han existido dos formatos
considerados como estándar, el
de 5 ¼ y el de 3 ½.
Ö CD-ROM - DVD
9 Pueden almacenar gran
información, aunque menor que
un disco duro, pero la velocidad
de recuperación de información
y la capacidad es menor.
9 Hay lectores, grabadores y
regrabadores
Tarjetas de Vídeo y Sonido
Ö TARJETAS DE VÍDEO
9 Los diferentes programas, envían
sus salidas a través de las
llamadas tarjetas de vídeo a la
pantalla.
9 Hoy en día, son gráficas e
incluyen aceleración por
hardware.
Ö TARJETAS DE SONIDO
9 Permiten escuchar música y
sonidos al ejecutar las
aplicaciones.
9 Es conveniente que admitan la
modalidad ‘full duplex’, para
programas de video
conferencias.
9 Se suele conectar al CD-ROM
para escuchar música.
Puertos (I)
Ö Sirven para conectar al PC los dispositivos externos

de E/S.
Ö Puerto serie (RS232C) COM 1,COM 2, etc.
Ö Puerto paralelo (CENTRONICS): LPT1 o PRN.
Ö Puerto USB
Puertos (II)
Periféricos Externos
Ö Dispositivos que se conectan a la placa base por

medio de los puertos.
Ö Los más comunes son:
9 Teclados
9 Ratones
9 Monitores
9 Impresoras
9 Scaners
9 Modems
Teclados y Ratones
Monitores
Ö CRT
Ö LCD (TFT)
Impresoras
Ö Matriciales
Ö Agujas
Ö Inyección de Tinta
Ö Laser
Escaners
Conclusiones
Ö Modularidad y características Plug & Play.

Ö La placa base contiene los elementos mínimos
necesarios.
Ö Las prestaciones de los computadores aumentan a un
ritmo vertiginoso.
Ö Las posibilidades de configuración y ampliaciones
posteriores son prácticamente ilimitadas.
Ö Por todo ello son computadores a la carta, creados al
gusto y necesidades del usuario.
Estructura General
de un
Sistema de Computación
Fede Pérez
Índice
TEMA 2 – Estructura General de un Sistemas de Computación
1. - Introducción
2. - Sección Primaria de Almacenamiento. Memoria Principal
2.1 – Estructura General
2.2 – Organización Interna de la Memoria
2.3 – Direccionamiento
2.4 – Operaciones de Lectura/Escritura en Memoria
2.5 – Propiedades Fundamentales de las Memorias
2.6 – Parámetros de Tiempo en Memoria
2.7 – Tipos de Memoria
2.8 – Jerarquías de Almacenamiento
3. - Unidad de Control de Procesos - C.P.U. –
3.1 – Unidad de Control
3.2 – Unidad Aritmético-Lógica - A.L.U. –
4. - Buses
4. - Descripción General
5. – Fases de Ejecución de una Instrucción
5.1 – Fase FETCH - Búsqueda o Lectura de una Instrucción
5.2 – Fase EXECUTE - Ejecución
Organización Básica de un SC
Estructura General de un SC – Memoria

Memoria Principal – Organización Interna
Memoria Principal – Direccionamiento
Direccionamiento cableado Direccionamiento cableado

en dos dimensiones en tres dimensiones
Memoria Principal – Operaciones de Lectura y Escritura
Lectura Escritura
1- Dirección de la palabra solicitada 1- Dirección de la palabra solicitada
es recogida en registro de es recogida en registro de
direcciones direcciones
2- Señal de control la operación 2- En el bus de datos la información
deseada (lectura) a escribir en memoria, quedando
3- La memoria decodifica la almacenado en el registro de
dirección, activa la celda datos de la memoria
correspondiente y deposita el 3- Señal de control la operación
dato en el registro de palabra; de deseada (escritura)
ahí la información pasa al bus de 4- El dato del registro de datos de
datos la M.P. se almacena en la célula
de memoria activada
Memoria Principal – Parámetros
Propiedades Fundamentales Parámetros de Tiempo

1- Coste por Bit Ciclo de Lectura: Tiempo que transcurre
2- Tiempo de Acceso desde que a la memoria llega la señal de
lectura, hasta que aparece el dato en el
3- Capacidad de Almacenamiento bus de datos
Ciclo de Escritura: Tiempo que transcurre

desde que a la memoria llega la señal de
escritura (se accede a la dirección)
Tiempo de Acceso: Espacio mínimo de

tiempo requerido entre accesos sucesivos
(lectura/escritura) a una memoria
Tipos de Memoria
De Lectura y Escritura - RAM (Random Access Memory / Read-Write Memory)
9Dinámicas (DRAM)
9Estáticas (SRAM)
De Solo Lectura - ROM (Read Only Memory)
9ROM (Read Only Memory)
9PROM (Programmable Read Only Memory)
9EPROM (Erasible Programmable Read Only Memory)
9EEPROM (Electrically Erasible Programmable Read Only Memory)
SRAM DRAM ROM/PROM EPROM/EEPROM FLASH

R/W R/W R/W R R R/W
Direccionamiento Si Si Si Si Si
aleatorio
Volatibilidad Si Si No No No
Capacidad Alta Muy Alta Baja Baja Muy Alta
Tiempo de Acceso Alto Muy Alto Bajo Bajo Medio
Jerarquía de Almacenamiento
Registro accionador
de acceso directo
Almacenamiento
pista eje
sector
Caché
Memoria Principal
Disco Electrónico
Cabeza de
Almacenamiento
lectura y
secundario
Disco Magnético cilindro escritura
Disco Optico
brazo
Cinta Magnética plato
Tasa de Transferencia: es la rapidez con que Latencia Rotacional: es el tiempo que el sector
fluyen los datos de la unidad de disco a la deseado tarda en girar hasta quedar debajo de
CPU la cabeza de disco
Tiempo de Posicionamiento o Tiempo de Acceso Controladores de Disco: Se encargan de La
Aleatorio: es el tiempo que tarda en mover el transferencia de datos por los buses
brazo del disco al cilindro deseado
Unidad de Control – Acepciones y Funciones
Acepciones Funciones
1- Microprocesador (µP): la Unidad 1- selecciona e interpreta las
Aritmético-Lógica (ALU) y la Unidad Central
instrucciones del programa
(UC)
2- Procesador Central: el µP (UC y ALU)

2- controla el flujo de datos desde y
más la Memoria Principal (MP) hacia la memoria
3- Ordenador personal (PC): la Placa 3- supervisa el resto de componentes de

Base (µP+MP+...), Unidad de Alimentación, la CPU
Dispositivos de Almacenamiento Internos
(discos, cintas, ...), ...
Unidad de Control – Estructura General

Unidad de Control – Registro de Instrucciones
Registro de Instrucciones
Código Modo Campo

Instrucción = de + de + de
Operación Direccionamiento Direcciones
C.O. M.D. C.D.
Modos de Direccionamiento
1- Directo:
Absoluto
Relativo
2- Indirecto
3- Inmediato
Unidad Aritmético-Lógica – ALU
Flags de Estado
Flag de Cero
Flag de Acarreo
Flag de Desbordamiento (Overflow)
Flag de Paridad
Buses
Tipos de Buses
1- Bus de Datos
2- Bus de Direcciones
3- Bus de Control
Líneas de Control
Líneas de Estado
Descripción General
Fases de Ejecución de una Instrucción
Fase Fetch Fase Execute

- Lectura de una Instrucción - Lectura de operandos y
decodificación de la instrucción
- Ejecución de la operación
- Almacenamiento de resultados
1- Transferir dirección desde 1.1- Impulsos al secuenciador

Contador de Programa 1.2- Acciones del secuenciador
2- Activación de celda y paso a 1.3- Acceso a operandos
registro de palabra 2- Ejecución de la instrucción
3- Instrucción hasta registro de 3- Almacenamiento de resultados
instrucciones
Lenguajes de Programación
Fede Pérez
Índice
TEMA - Lenguajes de Programación
1. - Programación
2. - Objetivos de la Programación
3. – Tipos de Lenguajes
3.1 – Lenguaje Máquina
3.2 – Lenguajes Ensambladores
3.3 – Lenguajes del Alto y Bajo Nivel
4. - Procesadores de Lenguajes
4.1 – Compiladores
4.2 – Intérpretes
5. - Herramientas de Programación
6. – Desarrollo de Programa que Suma Dos Números
Programación
Definición
Labor de desarrollar programas de
computador
Análisis Diseño Codificación
Enunciado Programa
Problema del Problema Algoritmo ( en lenguaje de
( algorítmico ) Programación )
Objetivos
1- Corrección
2- Claridad
3- Eficiencia
Ciclo de Vida del Software: Cascada de Böehm
Análisis y
Especificación
Diseño
Codificación
Validación y
pruebas
Operación y
Mantenimiento
Documentación
Lenguajes de Programación
Lenguaje Máquina Lenguaje Ensamblador

MOV AX, --
0101110111011001---------------------------------
--------------------------------------------------------- PUSH AX 0101110111011001---------------------------------
---------------------------------------------------------
01011100
------------------------- ---------------------
Datos 1 Programa Objeto 1 Resultados 1 ADD SP, 2 Ensa mblador ---------------------
---------------------------------------------------------
0111010101110001--------------------------------- ------------------------- ---------------------------------------------------------
0111010101110001--------------------------------- ---------------------
PUSH CX 01110101
Lenguaje Máquina 1 ------------------------- Lenguaje Máquina
END
Progra ma Objeto
Progra ma Fuente - Ejecutable -
Máquina Base 1 Máquina Base
01011100
---------------------------------------------------------
1111110001110000---------------------------------
---------------------------------------------------------
Datos Prg. Objeto Ejecuta ble Resultados
Datos 1 Programa Objeto 2 Resultados 1 ---------------------------------------------------------
---------------------------------------------------------
01110101
00000011110001110--------------------------------
Lenguaje Máquina
Lenguaje Máquina 2
Máquina Base 2 Máquina Base
Lenguajes de Alto Nivel

1- Independientes de la arquitectura del computador
2- Poseen instrucciones complejas
3- Notación cercana al lenguaje científico y natural
Lenguaje Máquina
0101110111011001----------------------------------
--------------------------------------------------------
Datos 1 Programa Ejecutable 1 Resultados 1

---------------------------------------------------------
0111010101110001---------------------------------
Lenguaje
LenguajeMáquina
Máquina11
Máquina Base 1
1111110001110000----------------------------------
--------------------------------------------------------
Datos 1 Programa Ejecutable 2 Resultados 1

---------------------------------------------------------
00000011110001110--------------------------------
Lenguaje
LenguajeMáquina
Máquina22
Máquina Base 2
Lenguaje Ensamblador
a) Obtención del MOV AX, --

PUSH AX 0101110111011001--------------------------------- 01011100
programa -------------------------
---------------------------------------------------------
---------------------
ejecutable ADD SP, 2 Ensamblador ---------------------
------------------------- ---------------------------------------------------------
0111010101110001--------------------------------- ---------------------
PUSH CX 01110101
------------------------- Lenguaje
LenguajeMáquina
Máquina
END
Programa
Programa Fuente Ejecutable
Máquina Base
b) Ejecución del programa 01011100

---------------------------------------------------------
ejecutable Datos Programa Ejecutable Resultados

---------------------------------------------------------
01110101
Lenguaje
LenguajeMáquina
Máquina
Máquina Base
Procesadores de Lenguajes
0101110111011001--------------------------------- 01111010
--------------------------------------------------------- --------------------
Tra ductor 1 --------------------
---------------------------------------------------------
--------------------
0111010101110001--------------------------------- --------------------
--------------------
/* PROGRA -- Lenguaje Máquina 1 --------------------
#include --- --------------------
--------------------
11001000
void main ( )
{
int Cont, Edad --
Progra ma Ejecuta ble
-----------------------
printf (“El resul -
Máquina Base 1 ( en la má quina 1 )
}
0111101111011101--------------------------------- 01111111
Progra ma Fuente --------------------------------------------------------- --------------------
PROGRAMA.C Tra ductor 2 --------------------
---------------------------------------------------------
--------------------
1111010101010111--------------------------------- --------------------
--------------------
Lenguaje Máquina 2 --------------------
--------------------
--------------------
11011011
N OTA: Un compila dor (tra ductor) cruzado es
ca pa z de Genera r código para una Progra ma Ejecuta ble
má quina diferente de a quella en la
que se ejecuta
Máquina Base 2 ( en la máquina 2 )
Intérpretes
Programa Fuente
PROGRAMA.BAS
REM PROGRAMA.BAS
INPUT “Introduce el valor : “, Valor

Datos INPUT “ la cantidad : “, Cant Resultados
Total = Valor*Cant
PRINT “El precio total es: “, Total
Lenguaje
LenguajeFuente
Fuente
0101110111011001----------------------------------
--------------------------------------------------------
Intérprete
---------------------------------------------------------
0111010101110001---------------------------------
Lenguaje
LenguajeMáquina
Máquina
Máquina Base
Compiladores
Compilado
/* PROGRA --
#include -- 0101110111011001--------------------------------- 01011100
--------------------------------------------------------- ---------------------
Compilador ---------------------
void main ( )
{ ---------------------------------------------------------
0111010101110001---------------------------------
---------------------
01110101 Ejecución
int Cont, Edad --
----------------------- Lenguaje Máquina
printf (“El resul - Programa Objeto Progra ma Objeto
} - N o ejecuta ble - - Ejecuta ble -
PROGRAMA.OBJ
PROGRAMA.EXE
Progra ma Fuente
PROGRAM A.C
Máquina Base 01111010
--------------------
--------------------
--------------------
Datos -------------------- Resultados
--------------------
--------------------
Enlazado --------------------
--------------------
11001000
01011100 Lenguaje Máquina
---------------------
--------------------- 0101110111011001--------------------------------- 01111010
---------------------------------------------------------
--------------------- --------------------
01110101 Enlaza dor (Linker) --------------------
--------------------------------------------------------- --------------------
0111010101110001--------------------------------- --------------------
PROGRAM A.OBJ --------------------
Lenguaje Máquina --------------------
-------------------- Máquina Base
01111000 --------------------
--------------------- 11001000
---------------------
---------------------
11010001
Progra ma Objeto
Máquina Base - Ejecuta ble -
RUTIN AS.LIB
PROGRAMA.EXE
Compiladores
Caso General
0101110111011001------------- 01011100
/* PROGRA -------------------------------------
Compilador
---------------------
#include ---------------------
-------------------------------------
void main ( )
0111010101110001
---------------------
{ Lenguaje Máquina
01110101
int A --
printf (“El res-
} Progra ma Objeto
PROG_1.OBJ
Progra ma Fuente
PROG_1.C Máquina Base 11110000
---------------------
---------------------
--------------------- 0101110111011001------------- 01111010
-------------------------------------
--------------------
.../... 01100111
Progra ma Objeto
Enla zador (Linker)
-------------------------------------
0111010101110001
--------------------
--------------------
PROG_2.OBJ Lenguaje Máquina --------------------
--------------------
0101110111011001------------- 00010000 --------------------
/* PROGRA -------------------------------------
Compilador
--------------------- --------------------
void InterCamb (int ------------------------------------- --------------------- --------------------
{ 0111010101110001
--------------------- Máquina Base 11001000
int Temp --
---------------------
Lenguaje Máquina 01011111
return -----------
} Progra ma Objeto
PROG_N .OBJ Progra ma Objeto
Progra ma Fuente - Ejecutable -
PROG_N .C 00010011
Máquina Base
--------------------- PROGRAMA.EXE
---------------------
---------------------
01100001
Progra ma Objeto
RUTIN AS.LIB
Librerías: Bibliotecas Estáticas
01011100
---------------------
--------------------- 0101110111011001---------------------------------- 01011100
--------------------------------------------------------
--------------------- --------------------
01110101 Enlazador (Linker) --------------------
--------------------------------------------------------- --------------------
0111010101110001--------------------------------- 01110101
PROGR_1.OBJ --------------------
Lenguaje
LenguajeMáquina
Máquina --------------------
--------------------
01111000 --------------------
--------------------- 11001000
---------------------
---------------------
11010001
Programa Ejecutable
Máquina Base PROGR_1.EXE
RUTINAS.LIB
11100100
---------------------
01110000 0101110111011001---------------------------------- 11100100
--------------------------------------------------------
--------------------
Enlazador (Linker) 01110000
PROGR_2.OBJ --------------------------------------------------------- --------------------
0111010101110001--------------------------------- --------------------
-------------------- Código de las rutinas
Lenguaje
LenguajeMáquina
Máquina --------------------
11001000
(copiado de la Biblioteca)
01111000
---------------------
---------------------
---------------------
11010001
Programa Ejecutable
Máquina Base PROGR_2.EXE
RUTINAS.LIB
Librerías: Bibliotecas Estáticas
Ejecución utilizando bibliotecas estáticas
01111010
--------------------
--------------------
--------------------
PROGR_1.EXE 01110101
--------------------
--------------------
-------------------- Código
-------------------- de las rutinas
01111010 11001000
--------------------
-------------------- 11100100
-------------------- --------------------
PROGR_1.EXE 01110101 01110000
-------------------- PROGR_2.EXE -----------------------
-------------------- -----------------------
-------------------- Código ----------------------- Código
-------------------- de las rutinas ----------- de las rutinas
11001000 11001000
Lenguaje
LenguajeMáquina Lenguaje
Máquina LenguajeMáquina
Máquina
Máquina Base Máquina Base
Librerías: Bibliotecas Dinámicas

01011100
---------------------
--------------------- 0101110111011001---------------------------------- 01011100
--------------------------------------------------------
--------------------- -------------------------
01110101 Enlazador (Linker) -------------------------
--------------------------------------------------------- ------------------------- Los programa
0111010101110001--------------------------------- 01110101-------------
PROGR_1.OBJ ejecutables
Lenguaje
LenguajeMáquina
Máquina ”Uso de Librería necesitan el
01111000 Rutinas.DLL” archivo
--------------------- RUTINAS.DLL
--------------------- Programa Ejecutable
--------------------- PROGR_1.EXE para poderse
11010001 ejecutar
Máquina Base
RUTINAS.DLL
01111000
11100100 ---------------------
--------------------- ---------------------
01110000 0101110111011001---------------------------------- 11100100 ---------------------
--------------------------------------------------------
-------------------- 11010001
Enlazador (Linker) 01110000 -------
PROGR_2.OBJ ---------------------------------------------------------
0111010101110001--------------------------------- ”Uso de Librería RUTINAS.DLL
Lenguaje Rutinas.DLL”
LenguajeMáquina
Máquina
01111000
--------------------- Programa Ejecutable
---------------------
--------------------- PROGR_2.EXE
11010001
Máquina Base
RUTINAS.DLL
Librerías: Bibliotecas Dinámicas
Ejecución Utilizando Bibliotecas Dinámicas 01011100
PROGR_1.EXE -------------------------
-------------------------
-------------------------
01110101-------------
”Uso de Librería
Rutinas.DLL”
01011100
PROGR_1.EXE ------------------------- 11100100
------------------------- --------------------
------------------------- 01110000 -------
01110101------------- PROGR_2.EXE
”Uso de Librería
”Uso de Librería
Rutinas.DLL”
Rutinas.DLL”
01111000 01111000
------------------------- -------------------------
------------------------- RUTINAS.DLL -------------------------
RUTINAS.DLL ------------- -------------
11010001 11010001
Lenguaje
LenguajeMáquina Lenguaje
Máquina LenguajeMáquina
Máquina
Máquina Base Máquina Base
Herramientas de Programación
Programa Ejecutable
PROGRAMA.EXE
01111010
------------------------------------- Resultados
Datos -------------------------------------
-------------------------------------
-------------------------------------
11001000
Lenguaje Máquina
0101110111011001---------------------------------
---------------------------------------------------------
Depura dor TRAZA DEL

---------------------------------------------------------
0111010101110001--------------------------------- PROGRAMA
Lenguaje Máquina
Entornos de Programación
Máquina Base /* PROGRA
0101110111011001--------------------------------- #include ---
--------------------------------------------------------- Progra ma
Depuradores
void main ( ) Fuente
Editor {
PROGRAM A.C
int A --
--------------------------------------------------------- printf (“El res-
0111010101110001---------------------------------
}
/* PROGRA
#include --- 1101110111011111---------------------------------
Progra ma --------------------------------------------------------- 01011100 Progra ma
Fuente void main ( ) ---------------------
{ Compilador Objeto
PROGRAMA.C int A --
---------------------
printf (“El res- --------------------------------------------------------- 01110101 PROGRAMA.OBJ
} 0000010101110001---------------------------------
Progra ma
01011100
Objeto
--------------------- 01111010
0001100110010001---------------------------------
--------------------- --------------------------------------------------------- --------------------
PROGRAMA.OBJ
01110101 -------------------- Progra ma
Enlazador (Linker) -------------------- Ejecuta ble
--------------------------------------------------------- -------------------- PROGRAM A.EXE
Progra ma Objeto 01111101 1111011101100001---------------------------------
Libreria de rutina s --------------------- 11001000
RUTIN AS.LIB 00000100
01111010
Progra ma --------------------
Ejecuta ble -------------------- 0001110000011000--------------------------------- Resultados
PROGRAMA.EXE -------------------- ---------------------------------------------------------
--------------------
11001000 Depurador
---------------------------------------------------------
0100000101000001--------------------------------- TRAZA DEL
Datos PROGRAMA
Suma de dos Números 1
Diseño
Sumar
dos números
Obtener Obtener Calcular Mostrar valor

Sumando 1 Sumando 2 la suma de la suma
Pedir Leer Pedir Leer

Número Número Número Número
Basic
REM
REM Programa en BASIC: SUMA_BAS.BAS
REM
INPUT "Introduce un Nº entero: ", iEntero_1

INPUT "Introduce otro entero: ", iEntero_2
iSuma = iEntero_1 + iEntero_2
PRINT "La suma es: ", iSuma
Suma de dos Números 2
Pascal C
(* Programa en PASCAL: SUMA_PAS.PAS *) /* Programa en C: SUMA_C.C */
PROGRAM suma_pas ; #include <stdio.h>

VAR
iEntero_1, iEntero_2, iSuma : Integer ; void main (void)
{
BEGIN int iEntero_1, iEntero_2, iSuma ;
Write ('Introduce un Nº entero: ') ;
ReadLn (iEntero_1 ) ; printf ("Introduce un Nº entero: ") ;
scanf ("%d", &iEntero_1) ;
Write ('Introduce otro entero: ') ;
ReadLn ( iEntero_2 ) ; printf ("Introduce otro entero: ") ;
scanf ("%d", &iEntero_2) ;
iSuma := iEntero_1 + iEntero_2 ;
iSuma = iEntero_1 + iEntero_2 ;
WriteLn ('La suma es: ', iSuma)
END. printf ("La suma es: %d", iSuma) ;
}
Suma de dos Números – Relación entre Lenguajes
;|***
;|*** /* Programa en C SUMA_C.C */ ;|*** iSuma = iEntero_1 + iEntero_2 ;
; Line 1 ;|***
;|*** ;|*** printf ("La suma es %d", iSuma) ;
;|*** #include <stdio.h> ; Line 16
; Line 3
;|*** *** 000039 8b 46 fc mov ax,WORD PTR [bp-4] ; iEntero_2
;|*** void main (void) *** 00003c 03 46 fe add ax,WORD PTR [bp-2] ; + iEntero_1
;|*** { *** 00003f 89 46 fa mov WORD PTR [bp-6],ax ; iSuma
; Line 6
PUBLIC _main *** 000042 50 push ax
_main PROC NEAR
*** 000043 b8 34 00 mov ax,OFFSET DGROUP:$SG172
*** 000000 55 push bp
*** 000046 50 push ax
*** 000001 8b ec mov bp,sp
*** 000047 e8 00 00 call _printf
*** 000003 b8 06 00 mov ax,6
;|*** }
*** 000006 e8 00 00 call __aNchkstk
; Line 17
; iEntero_1 = -2
*** 00004a 8b e5 mov sp,bp
; iEntero_2 = -4
*** 00004c 5d pop bp
; iSuma = -6
;|*** int iEntero_1, iEntero_2, iSuma ; *** 00004d c3 ret
;|***
;|*** printf ("Introduce un Nº entero: ") ;
; Line 9 _main ENDP
*** 000009 b8 00 00 mov ax,OFFSET DGROUP:$SG168 _TEXT ENDS
*** 00000c 50 push ax END
*** 00000d e8 00 00 call _printf ;|***
*** 000010 83 c4 02 add sp,2
;|*** scanf ("%d", &iEntero_1) ;
; Line 10 Ensamblador
*** 000013 8d 46 fe lea ax,WORD PTR [bp-2] ; iEntero_1
*** 000016 50 push ax Lenguaje máquina (hexadecimal)
*** 000017 b9 17 00 mov cx,OFFSET DGROUP:$SG169
*** 00001a 51 push cx Dirección de memoria (relativa)
*** 00001b e8 00 00 call _scanf
*** 00001e 83 c4 04 add sp,4
;|*** printf ("Introduce otro entero: ") ;
; Line 11
*** 000021 b8 1a 00 mov ax,OFFSET DGROUP:$SG170 Equivalencia de códigos
*** 000024 50 push ax
*** 000025 e8 00 00 call _printf
*** 000028 83 c4 02 add sp,2
;|*** scanf ("%d", &iEntero_2) ; En C: iSuma = iEntero_1 + iEntero_2
; Line 12 En Pascal: iSuma := iEntero_1 + iEntero_2
*** 00002b 8d 46 fc lea ax,WORD PTR [bp-4] ; iEntero_2
*** 00002e 50 push ax
*** 00002f b9 31 00 mov cx,OFFSET DGROUP:$SG171
*** 000032 51 push cx
*** 000033 e8 00 00 call _scanf
*** 000036 83 c4 04 add sp,4
Programación en C
Fede Pérez
Índice
TEMA - Lenguaje de Programación C
1. - Introducción
2. - Conceptos Básicos
2.1 – Tipos de Datos Base
2.2 – Funciones de Entrada/Salida
2.3 – Expresiones y Operadores
3. - Sentencias de Control
3.1 - Sentencias Selectivas
3.2 - Sentencias Repetitivas
4. - Funciones
5. – Datos Estructurados
5.1 – Arrays
5.2 – Cadenas de Caracteres
5.3 – Estructuras
6. – Ficheros
Historia del Lenguaje C
Historia
9 Nacimiento años 70 – laboratorios Bell Telephone – junto con UNIX
9 UNIX – Ken Thompson y Dennis Ritchie
9 Transferencia PDP-7 PDP-9, PDP-11
9 1970 (Ken Thompson) definición del lenguaje B (proviene del BCPL)
9 1972 (Dennis Ritchie) definición del lenguaje C
9 1973 (UNIX versión 5) 90% en C para PDP-11
9 Años 80 ANSI C estándar ISO
9 Mediados de los 80 C++ estándar ISO 1998
Características del Lenguaje C

Características
9 Lenguaje de propósito general
9 Poco tipificado
9 Cercano a la máquina
9 Variado juego de operadores
9 Reemplaza ventajosamente al ensamblador
9 Recursividad y reentrabilidad
9 Utilización natural de las funciones primitivas del sistema de explotación
Carencias
9 Manejo de tablas y cadenas de caracteres
9 Multiprogramación, control de procesos, sincronización
9 Entrada/Salida, ficheros
Solución
Programoteca Librería estándar
Componentes del Lenguaje C
Componentes del Lenguaje
9Compilador: software que traduce a lenguaje de

máquina el programa C contenido en uno o más
ficheros fuente
9Preprocesador: software que actúa siempre por

delante del compilador facilitando su tarea y la del
programador
9Librería Estándar: funciones agrupadas en un

conjunto de librerías de código objeto preprogramadas
que se venden o se entregan junto con el compilador
Estructura General de un Programa I

Programa
Conjunto de instrucciones que se ejecutan –ordinariamente– de modo secuencial
Función
División un programa muy grande en una serie de módulos mucho más
pequeños y manejables. A estos módulos se les ha sólido denominar de
distintas formas (subprogramas, subrutinas, procedimientos, funciones, etc.)
según los distintos lenguajes.
Ventajas de la Utilización de Funciones

1. Modularización
2. Ahorro de memoria y tiempo de desarrollo
3. Independencia de datos y ocultamiento de información
Programa Principal
Función concreta que juega el papel principal y que empieza a actuar
Esta función en el lenguaje C ha de llevar por titulo o nombre el de "main"
Estructura General de un Programa II
#include
Directivas de Preprocesador
#define
- Prototipos de funciones
Declaraciones Globales
- Variables globales
Programa Principal main()
Funciones de Usuario - Definición de funciones
Ficheros Fuente en C – Un Módulo

Ficheros Estándar Fichero Principal
stdio.h principal.c
#include <stdio.h>
... main()
{
...
f1(...);
...
}
f1(...)
{
...
f2(...);
...
}
f2(...)
{
...
}
Ficheros Fuente en C – Varios Módulos
Ficheros Estándar Fichero Principal Ficheros Secundarios
stdio.h principal.c aux1.c
#include <stdio.h> f3(...)
{
... main()
...
{
f4(...);
...
...
f1(...);
}
f5(...);
...
aux2.c
}
f4(...)
f1(...) {
{ ...
... f2(...);
f3(...); ...
... }
}
f2(...) aux3.c
{ f5(...)
... {
} ...
}
#include ”aux3.c”
Realización de un Programa en C – No Modular

Enlazador (Linker)
Compilador
Editor
principal.C principal.EXE
.LIB
Realización de un Programa en C – Modular
Compilador
principal.C principal.O
Editor
auxiliar.C auxiliar.O
Enlazador (Linker)
objeto.O principal.EXE
libreria.LIB
.LIB
Características de Edición de un Programa C

Características
9 Sensible a mayúsculas y minúsculas
9 Indentación y espacios en blanco
9 Sentencias (terminan en punto y coma “;” )
9 Bloques (delimitados entre llaves “{}” )
9 Elementos de un programa
Palabras reservadas
Funciones de librería estándar
Variables y funciones definidas por el programador
Características de Edición de un Programa C
Nombres de Ficheros y Extensiones
El nombre de un fichero consta de dos partes: el nombre base y la extensión.
Extensiones más Comunes
.c fichero fuente C
.h fichero de cabeceras
.o (.obj) fichero objeto resultante de la compilación de un fichero fuente. No es ejecutable
.out (.exe) fichero ejecutable
.lib librería estática
.dll librerías dinámicas
Depuración de un Programa
Errores
9 Errores de Sintaxis Ö Edición
9 Errores Lógicos Ö Algoritmo incorrecto
9 Errores de Regresión Ö Solución de errores
9 Errores de Ejecución Ö Situaciones imprevistas
Mensajes de Error
9 Error Fatal Ö Sistema Operativo
9 Error de Sintaxis Ö Compilador/enlazador
9 Advertencias (warnings) Ö Compilador/enlazador (no traba)
El Programa Principal
Programa Principal
Función concreta que juega el papel principal y que empieza a actuar
Esta función en el lenguaje C ha de llevar por titulo o nombre el de "main"
Declaraciones de la Función Main

main()
int main()
void main()
void main(void)
int main(int argc, char *argv[])
argc representa el número total de argumentos
argv es el puntero que señala una tabla en cuyos registros están
contenidos los argumentos bajo la forma de serie de caracteres
Primer Programa C
Edición (Fichero hola.c)
#include <stdio.h>
main()
{
printf(”Hola mundo!!\n”);
}
Compilado
Ejecución
Finalización de un Programa
Modos de Finalización de un Programa
1. Se llega al final del programa principal (función main)
2. La función main realiza una llamada a la sentencia return()
3. Cualquier función realiza una llamada a la función exit()
Ejemplo 1
#include <stdio.h> Ejemplo 3
main() #include <stdio.h>
{ #include <stdlib.h> /* necesario para
printf(”Esto sí se ejecuta\n”); exit() */
} main()
{
printf(”Esto sí se ejecuta\n”);
exit(0);
Ejemplo 2 printf(”Esto no se ejecuta\n”);
#include <stdio.h> }
main()
{
printf(”Esto sí se ejecuta\n”);
return(0);
printf(”Esto no se ejecuta\n”);
}
Elementos Base del Lenguaje C
Elementos Base
Existen seis clases de componentes sintácticos o
tokens en el vocabulario del lenguaje C:
1. Identificadores
2. Palabras Reservadas
3. Constantes
4. Operadores
5. Separadores
6. Comentarios
Identificadores I
Definición
Los identificadores son nombres que permiten señalar, mencionar, hacer
referencia a los diferentes objetos tratados por el programa. En particular a:
¾ las variables
¾ las funciones
¾ las constantes simbólicas
Reglas ANSI C
1. Un identificador se forma con una secuencia de letras (minúsculas de la a a la z; mayúsculas de
la A a la Z; y dígitos del 0 al 9).
2. El carácter subrayado o underscore (_) se considera como una letra más.
3. Un identificador no puede contener espacios en blanco, ni otros caracteres distintos de los citados,
como por ejemplo (* , ; . : - + etc.)
4. El primer carácter de un identificador debe ser siempre una letra o un (_), es decir, no puede ser
un dígito.
5. Se hace distinción entre letras mayúsculas y minúsculas. Así, Masa es considerado como un
identificador distinto de masa y de MASA.
6. ANSI C permite definir identificadores de hasta 31 caracteres de longitud.
Identificadores II
Ejemplos
Identificadores Correctos Identificadores Incorrectos
I 8080
BUFFER 1er
Direcci6n_Memoria Bus de datos
cas_01 cas:01
Z80 CP/M
Palabras Reservadas
Definición
Palabras clave necesarias para la sintaxis y semántica del lenguaje:
¾ especificadores de tipo de objeto
¾ especificadores de clase de memoria
¾ instrucciones de control
¾ operador simbólico
¾ etiquetas de control
Lista de Palabras Reservadas

Tipo Clase Instrucción Operador Etiqueta
int auto if sizeof case

char extern else default
short static while
long register do
signed volatile for
unsigned const switch
float typedef break
double continue
void goto
struct return
union
enum
Constantes
Definición
Valores que permanecen fijos durante la ejecución de un programa:
¾ números enteros
¾ números reales
¾ caracteres
¾ serie de caracteres
¾ expresiones con constantes
¾ constantes simbólicas
Tipos de Constantes
1. 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).
2. 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.
3. 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.
4. Constantes simbólicas. Las constantes simbólicas tienen un nombre (identificador) y en esto se

parecen a las variables. Sin embargo, no pueden cambiar de valor a lo largo de la ejecución del
programa. En C se pueden definir mediante el preprocesador (#define) o por medio de la
palabra clave const.
Expresiones Constantes
Formato Básico de Expresiones Constantes
¾ Una expresión real puede darse en notación decimal (2.56) como científica (2.56E-4)
¾ En una expresión tipo long se añade una L al final (200L)
¾ Una expresión tipo carácter se define entre comillas simples (’A’)
¾ Una expresión de cadena de caracteres se define entre comillas dobles (”expresión”)
Expresión de Números Enteros en Diferentes Bases
¾ Base Decimal: Expresión en formato normal. Ejemplo: 230 Tabla de Caracteres de Control
¾ Base Octal: Comienza por cero. Ejemplo: 0346
nueva línea NL o LF \n
¾ Base Hexadecimal: Comienza por cero-x. Ejemplo: 0xE6 tabulaci6n TAB o HT \t
retroceso BS \b
retorno de carro CR \r
avance de página FF \f
Definición de Constantes Mediante Directiva de Preprocesador antibarra \ \\
ap6strofe ‘ \’
Es posible definir constantes asociadas a un identificador por medio de comillas “ \”
sonido de alerta BELL \a
la directiva #define carácter nulo NULL \0
Ejemplo: octeto binario ddd \ddd
#define PI 3.141593
#define MAXIMO 255
#define MAXINT 32767
Operadores
Definición
Los operadores pueden estar representados por uno o por dos caracteres
especiales, por una palabra reservada, o por un especificador de tipo puesto
entre paréntesis.
Categorías de Operadores
¾ Operadores Monádicos o Unarios: preceden a un identificador, a una expresión o a una constante
¾ Operadores Diádicos o Binarios: establecen la relación entre dos términos o expresiones
¾ Operadores Triádicos o Ternarios: ponen en relación tres términos o expresiones
Tabla de Operadores
Unarios Binarios Ternarios
- == = ? :
* + != +=
& - > -=
! * >= *=
~ / < /=
++ % <= %=
-- | || |=
(tipo) & && &=
sizeof ˆ ˆ=
>> >>=
<< <<=
. ->
Separadores
Definición
Se puede considerar que los separadores están formados por:
¾ delimitadores
¾ espacios en blanco
Delimitadores
Son signos especiales que permiten al compilador separar y reconocer las
diferentes unidades sintácticas del lenguaje
Principales Signos Delimitadores

; termina una declaración de variable o una instrucci6n
, separa dos elementos consecutivos en una lista
( ) enmarca una lista de argumentos o de parámetros
[ ] enmarca la dimensi6n o el subíndice de una tabla
{ } enmarca un bloque de instrucciones o una lista de valores iniciales
Espacios en Blanco
Pueden estar constituidos por uno o varios caracteres "espacios" o "blancos";
de uno o varios caracteres de "TABulación", y del carácter de avance a la
línea siguiente, denominado normalmente nueva línea (newline). Estos
caracteres sirven para delimitar las diversas unidades sintácticas.
Comentarios
Definición
Los llamados comentarios o memorandums, propiamente no forman parte de
los elementos base del lenguaje, ya que son ignorados por el compilador y
sólo reflejados en el listado fuente del programa.
Tipos
1. Serie de caracteres que vaya encerrada entre los dos símbolos /* y
*/.Restricción: los comentarios no deben estar imbricados o anidados
2. ANSI C permite también otro tipo de comentarios, tomado del C++.

Todo lo que va en cualquier línea del código detrás de la doble barra (//)
Ejemplo
#include <stdio.h>
main()
{
/* Comentario en varias
líneas */
return(0); // comentario de línea
}
Tipos de Datos Básicos – Definición y Modificadores
Definición
Tres tipos fundamentales, que se expresan con la ayuda de palabras clave
reservadas en el lenguaje:
1. Números enteros (int)
2. Números reales (float)
3. Caracteres (char)
Modificadores
Calificación para adaptarse mejor a los diversos tamaños de la palabra
interna del microprocesador, con el fin de mejorar la precisión o de reducir el
espacio ocupado en memoria :
1.short para un entero corto
2.long para un entero largo
3.unsigned para un entero sin signo
4.double para un número real flotante de doble precisión
Ejemplo
unsigned int
signed char
long int
unsigned long int
Tipos de Datos Básicos – Notaciones
Tipos de datos fundamentales (notación completa)
Datos enteros char signed char unsigned char
signed short int signed int signed long int
unsigned short int unsigned int unsigned long int
Datos reales float double long double
Tipos de datos fundamentales (notación abreviada)
Datos enteros char signed char unsigned char
short int long
unsigned short unsigned unsigned long
Datos reales float double long double

Tipos de Datos Básicos – Tamaños y Rangos
Tipo Tamaño de palabra

16 bits 32 bits
char 8 bits 8 bits
int 16 bits 32 bits
short 16 bits 16 bits
long 32 bits 32 bits
unsigned 16 bits 32 bits
float 32 bits 32 bits
double 64 bits 64 bits
Operador sizeof()
El operador sizeof se utiliza para determinar el número
de bytes de un variable o un tipo
int a;
sizeof(a); sizeof(unsigned int);
Tipos de Datos Básicos – Rangos
Rangos para máquina de 16 bits

Tipo Rango
char -128..127
unsigned char 0.255
int -32768..32767
short -32768..32767
long -232..232-1
unsigned 0..65535
float 3.4E-38..3.4E+38
double 1.7E-308..1.7E+308
long double 3.4E-4932.. 1.1E+4932
Tipos de Datos Básicos – Declaración de variables
Declaración
<Clase de memoria> [tipo de dato] [[Identificador]<=Valor Inicial>, ...];
Declaración Simple
char ccar;
unsigned int inum;
float freal;
Declaración Múltiple
char ccar, cdat;
unsigned int inum, icoorx;
float freal, fnum;
Declaración y Asignación
char ccar = ’A’;
unsigned int inum = 12432, icoorx = 5;
float freal = 0.14, fnum = -4.2812e-4;
Punteros
Definición Operadores de Punteros
¾ Las variable de tipo puntero representan direcciones donde ¾ Si px es un puntero (dirección): *px es el
almacenar valores. Es importante diferenciar entre puntero contenido del puntero (el valor almacenado
(espacio de memoria donde se almacena la dirección) y la en la dirección)
propia dirección del puntero.
¾ Si x es la variable: &x es la dirección de
¾ Se declaran con un asterisco delante del identificador de memoria donde está almacenada la variable
variable
Ejemplo
int *px, x; /* px es un puntero a entero y
x es un entero */
El Tipo void Dirección Contenido Gráfica

px
¾ La declaración de punteros genéricos a main() px35; ? ? ? ? ? x
direcciones se asocian al tipo void { x39; 0 0 0 3 3
¾ Declarar un variable que no sea puntero int *px, x = 3;
px
de tipo void no tiene sentido px35; 0 0 0 39 39 x
px = &x; // px apunta a x x39; 0 0 0 3 3
px
Ejemplo px35; 0 0 0 39 39 x
void *pv, v; /* La variable v *px = 5; // x vale 5
x39; 0 0 0 5 5
está mal declarada */ }
Ámbito de las Variables
La declaración de las variables lleva asociado un ámbito, dentro del cual la
variable es visible:
¾ Ámbito Global: La variable es visible en todas las funciones del
programa
¾ Ámbito Local: La variable es visible dentro del bloque o función en el
que encuentra definida. (Tiene prioridad sobre el ámbito global)
Ejemplo
int x, y; // variables glogales
main()
{
float x, z; // variables locales
/* Aquí x, z son reales e y un entero */

}
/* Aquí x e y son variables enteras */

/* La variable z no existe fuera de la función
donde está definida */
Conversiones de Tipo – Casting

Definición
A menudo es necesario convertir valores de variables o expresiones de un tipo a otro
diferente. Hay dos tipos de conversiones:
¾ Conversiones Implícitas (Promoción): Las realiza automáticamente el programa.
Variables o expresiones de menor rango promocionan a rangos superiores.
¾ Conversiones Explícitas (Casting): Conversión forzada por el programador. Se
utiliza el tipo a convertir entre paréntesis.
Rangos de Conversiones Implícitas

long double > double > float > unsigned long > long > unsigned int > int > char
Ejemplo de Casting
int inum;
float rnum;
char ccar;
rnum = 65.0
inum = (int)rnum; //inum vale 65
ccar = (char)inum; //ccar vale 65 (código ASCII de ’A’)
Código ASCII
ASCII
American
Standard
Code
Information
Interchange
Código ASCII – Caracteres imprimibles y no imprimibles

Código ASCII – Caracteres extendidos
Operadores
Definición
Los operadores pueden estar representados por uno o por dos caracteres especiales, por una palabra
reservada, o por un especificador de tipo puesto entre paréntesis.
Tipos de Operadores
¾ Operadores aritméticos ¾ Operadores de incremento y decremento
¾ Operadores de manipulación de bits ¾ Operadores de relación
¾ Operadores de asignación ¾ Operadores de dirección
Categorías de Operadores
¾ Operadores Monádicos o Unarios: preceden a un identificador, a una expresión o a una constante
¾ Operadores Diádicos o Binarios: establecen la relación entre dos términos o expresiones
¾ Operadores Triádicos o Ternarios: ponen en relación tres términos o expresiones
Tabla de Operadores
Unarios Binarios Ternarios
- == = ? :
* + != +=
& - > -=
! * >= *=
~ / < /=
++ % <= %=
-- | || |=
(tipo) & && &=
sizeof ˆ ˆ=
>> >>=
<< <<=
. ->
Operadores Aritméticos
Operadores Aritméticos
+ la adición
- la sustracción y el menos monádico
* la multiplicación
/ la división
% el residuo o resto de la división
Nota División Entera vs Real

El operador de asignación básico es el igual (=) Depende de los operandos:
4/3 Æ1 Entero
Ejemplo 4.0 / 3 Æ 1.3333 Real
4/ 3.0 Æ 1.3333 Real
#include <stdio.h> 4.0 / 3.0 Æ 1.3333 Real
main() /* comprobaciones de prioridad */
{
int c = 2, d = 3, y = 4;
printf(”c * d %%y = %d\n”, c * d % y); Solución
printf(”(c * d) %%y = %d\n”, (c * d) % y); c * d % y = 2
printf(”c * (d %%y) = %d\n”, c * (d % y)); (c * d) % y = 2
} c * (d % y) = 6
Operadores de Manipulación de Bits

Operadores de Manipulación de Bits
& Y lógico inclusivo (AND)
| O lógico inclusivo (OR)
^ O lógico exclusivo (XOR)
˜ negación, complementos a uno
<< desplazamiento hacia la izquierda
>> desplazamiento hacia la derecha
Ejemplo
#include <stdio.h>
main()
{
long n = 0x12345678; // entero sobre 32 bits
printf(”%lx & 0X0F0F0F0F = %lx”, n, n & 0x0f0f0f0f);

}
Solución
12345678 & 0X0F0F0F0F = 02040608
Operadores de Asignación
Operadores de Asignación
= Asignación
+= Suma y asignación
–= Resta y asignación
*= Producto y asignación
/= División y asignación
%= Resto y asignación
|= OR y asignación
&= AND y asignación
^= XOR y y asignación
>>= Desplazamiento a izquierdas y asignación
<<= Desplazamiento a derechas y asignación
Utilización de Operadores Combinados Asignación Múltiple
Operador Explicación Uso i = j = k = 0; /* primero k = 0 y

+= a = a + b a += b luego j = 0 y
*= a = a * b a *= b
luego i = 0 */
-= a = a - b a -= b
Asignación Anidada
/= a = a / b a /= b
%= a = a % b a %= b car = 0x5f & (c = getchar()); // mayúscula
Operadores de Incremento y Decremento

Operadores de Incremento y Decremento
++ Incremento de una unidad
-- Decremento de una unidad
Utilización de Operadores Combinados
Función Abreviatura Operador izda Operador dcha

x = x + 1 x += 1 ++x x++
x = x - 1 x -= 1 --x x--
Ejemplos
a = 3; b = a++; // a = 4, b = 3
a = 3; b = ++a; // a = 4, b = 4
a = 3; b = a--; // a = 2, b = 3
a = 3; b = --a; // a = 2, b = 2
Operadores de Relación
Operadores de Comparación Operadores Lógicos
> Mayor que Negación monádica (NOT)
>= Mayor o igual a && Intersección lógica (AND)
< Menor que || unión lógica (OR)
<= Menor o igual a

== Igual a, igualdad
Valores Booleanos
!= Distinto de, desigualdad
Verdadero 1
Falso 0
Ejemplos
a = 3 > 7; // a vale 0 (falso)
a = (3 > 2 || 5 == 4) && !1 // a vale 0 (falso)
(index < MAX - 1 && (c = getchar()) != '\n') && c != EOF)
Prioridad de Operadores
Clasificación de los Operadores según sus Prioridades
( ) [ ] -> .
! ˜ ++ -- - * & (type) sizeof
* / %
+ -
<< >>
< <= > >=
== !=
&
ˆ
|
&&
||
? :
= += -= *= /= %= >>= <<= &= |= ˆ=
,
Funciones de E/S Básicas
Definición
Las funciones de E/S en C no pertenecen a las palabras reservadas del lenguaje. Son funciones de la librería estándar
cuyo formato se encuentra en el fichero de cabecera stdio.h.
Las funciones de E/S básicas recogen/insertan variables o constantes en los ficheros de E/S
(stdin/stdout teclado/monitor)
Tipos
Las principales funciones de E/S se dividen por su propósito:
¾ Funciones de E/S de caracteres: recoger/insertar un carácter del fichero de E/S
9 getchar()/putchar()
¾ Funciones de E/S de cadenas de caracteres: recoger/insertar una cadena de caracteres del fichero de E/S
9 gets()/puts()
¾ Funciones de E/S con formato: leer/escribir con formato del fichero de E/S
9 scanf()/printf()
Funciones de E/S Básicas – E/S de Caracteres

getchar()
Leer un carácter desde techado: caracter = getchar();
putchar()
Presenta un carácter en pantalla: putchar(caracter);
Ejemplo de getchar/putchar
#include <stdio.h> // necesario para utilizar funciones de E/S
main()
{
char ccar; // variable caracter
ccar = getchar(); // recoge carácter de teclado

putchar(ccar); // escribe carácter en monitor
putchar(’A’); // escribe una A en monitor
putchar(getchar()); // escribe lo leído
}
Funciones de E/S Básicas – E/S de Cadenas de Caracteres
gets()
Leer una cadena de caracteres desde techado: gets(cadena);
puts()
Presenta una cadena de caracteres en pantalla: puts(cadena);
Ejemplo de gets/puts
#include <stdio.h> // necesario para utilizar funciones de E/S
main()
{
char cadena[100]; // variable cadena de caracteres
gets(cadena); // recoge la cadena de teclado

puts(cadena); // escribe la cadena en monitor
puts(”Hola socio”); // escribe la cadena constante en monitor
puts(gets(cadena)); // escribe lo leído
}
Funciones de E/S Básicas – printf()

printf()
Escribir en pantalla con formato: printf (”formato”, arg1, arg2, ..., argn);
¾ formato: cadena de formato de salida de datos.
¾ argi : argumentos a incluir dentro del formato (pueden ser variables o expresiones).
Formato Expresión Resultado

%d, %i entero Entero decimal con signo Ejemplo
%u entero Entero decimal sin signo
%o
#include <stdio.h>
entero Entero octal sin signo
%x, %X entero Entero hexadecimal sin signo
%f real Real en notación punto #define PI 3.141593
%e, %E real Real en notación científica
%g, %G real Real en notación más corta
%c carácter Carácter main()
%s string Cadena de caracteres
%p puntero Dirección de memoria
{
%ld, %lu, … entero largo Entero largo (distitos formatos) int inum = 3;
char ccar = ’A’;
Otras Opciones de Formato
¾ Signo ”–”: ajuste a la izquierda. printf(”Hola mundo !!\n”);
printf(”El número %8d\n”, inum);
¾ número: longitud mínima en caracteres
printf(”Un número %d y un carácter %c\n”,
¾ punto decimal: precisión de la parte fraccionaria inum + 2, ccar);
printf(”El valor de PI es %6.4f\n”, PI);
}
Funciones de E/S Básicas – scanf()
scanf()
Leer de teclado con formato: scanf (”formato”, dir1, dir2, ..., dirn);
¾ formato: cadena de formato de entrada de datos.
¾ diri : argumentos a incluir dentro del formato (direcciones de variables donde se almacenaran valores leídos).
Nota Es importante destacar que los argumentos son direcciones. Cuando se utilizan variables base es necesario
utilizar el operador de indirección &.
Ejemplo
#include <stdio.h>
main()
{
int inum, *pinum;
float rnum;
char ccar;
scanf(”%d”, &inum); // lee un entero y lo almacena en inum

scanf(”%f %c”, &rnum, &ccar); // lee un rnum y ccar
scanf(”%d”, pinum); // PELIGROSO
pinum = &inum;
scanf(”%d”, pinum); // CORRECTO, lee inum
}
Funciones de E/S Básicas – scanf() Lectura de strings

Ejemplo
#include <stdio.h>
main()
{
char *pstr, str[100], cad[20];
scanf(”%s”, pstr); // PELIGROSO

scanf(”%s”, str); // CORRECTO, lee str hasta blanco o fin de línea
pstr = str;
scanf(”%s”, pstr); // CORRECTO, lee str hasta blanco o fin de línea
scanf(”%[^\n]”, str); // Lee toda la línea sobre str
scanf(”%s %*s %s”, cad, str); /* Lee cad hasta blanco, deja una palabra y la
siguiente palabra sobre str hasta blanco o fin de línea */
}
Funciones de E/S Básicas – printf()/scanf() Ejemplo
Ejemplo
#include <stdio.h>
#define DIAS_ANIO 365
main()
{
char nombre[100];
int dias, anios;
printf(”¿Cual es tu nombre? ”);

scanf(”%s”, nombre);
printf(”¿Y tu edad? ”);

scanf(”%d”, &anios);
dias = anios * DIAS_ANIO;
printf(”%s tienes aproximadamente %d días”, nombre, dias);

}
Solución
¿Cual es tu nombre? Jose
¿Y tu edad? 20
Jose tienes aproximadamente 7300 días
Sentencias de Control
Definición
Las sentencias de control van a determinar la cadena de ejecución de las instrucciones.
Tipos de Sentencias de Control

¾ Sentencias Condicionales o Selectivas: permiten la bifurcación de la cadena de ejecución
9 Sentencia if
9 Sentencia if ... else
9 Sentencia switch
¾ Sentencias Repetitivas o Iterativas: permiten la repetición de un conjunto de instrucciones
9 Sentencia while
9 Sentencia do ... while
9 Sentencia for
Sentencia if
Diagrama de Flujo
falso
¿condición?
verdadero
expresión(es)
Ejemplo
#include <stdio.h>
#define MAXIMO 100

Ejecución
if(condición) main()
{ {
int inum;
expresión(es)
} printf(”Dame un número -> ”);
scanf(”%d”, &inum);
if(inum > MAXIMO)

{
printf(”El número introducido es mayor que el máximo\n”);
}
}
Sentencia if...else
Diagrama de Flujo
verdadero falso
¿condición?
expresión(es) if expresión(es) else
Ejemplo
#include <stdio.h>
#define MAX_EDAD_JOVEN 25
Ejecución
main()
if(condición) {
int edad;
{
expresión(es) if printf(”Dime tu edad -> ");
scanf(”%d”, &edad);
}
else if(edad <= MAX_EDAD_JOVEN)
{ {
printf(”Con %d años eres un chaval\n”, edad);
expresión(es) else }
} else
{
printf(”Con %d años no estás para muchos trotes\n”, edad);
}
}
Sentencia if...else Anidadas
Ejemplo de Ejecución
if(condición1)
{
if(condición2)
{
expresión(es) if condición 2
if(condición3)
{
}
}
else
{
expresión(es) else condición 2
}
}
else
{
if(condición4)
{
}
else
{
expresión(es) else condición 4
}
}
Sentencia switch
Ejecución
switch(variable_opción)
{
case opcion_1:
expresión(es) opcion_1; Ejemplo
break; #include <stdio.h>
case opcion_2: main()

expresión(es) opcion_1; {
char letra;
break;
printf(”Dame una inicial y te daré un animal -> ”);
... scanf(”%c”, &letra);
case opcion_N: switch(letra)

expresión(es) opcion_N; {
break; case ’a’:
printf(”antílope\n”);
break;
default: case ’b’:
expresión(es) default; printf(”buitre\n”);
} break;
case ’c’:
printf(”cocodrilo\n”);
break;
default:
printf(”No se me ocurre…\n”);
}
}
El Operador Condicional
Operador Condicional
": Condicionalidad
Equivalencia a Sentencia Condicional if..else

si (expresión1) entonces expresión2 en_caso_contrario expresión3
expresión1 ? expresión2 : expresión3
Ejemplo
#include <stdio.h>
if(num > 0)
main() {
{ abs = num;
float num, abs; }
nte
else
printf(”Dame un número -> ”);
iv ale {
u
scanf(”%f”, &num); eq abs = -num;
}
abs = num > 0 ? num : -num;
printf(”El valor absoluto de %6.4f es %6.4f\n”, num, abs);

}
Sentencia while
Diagrama de Flujo Ejecución
while(condición)
{
expresión(es)
falso }
¿condición?
verdadero
expresión(es)
Ejemplo
#include <stdio.h>
#define TOPEMINIMO 250
main()
{
int total = 0, nuevas;
while(total < TOPEMINIMO)

{
printf(”Tienes %d piezas acumuladas\n”, total);
printf(”Cuantas piezas nuevas tienes -> ”);
scanf(”%d”, &nuevas);
total += nuevas;
}
printf(”Has acumulado %d piezas.\n”, total);

}
Sentencia do...while
Diagrama de Flujo Ejecución
do
{
expresión(es)
expresión(es) }
while(condición);
falso
¿condición?
verdadero
Ejemplo
#include <stdio.h>
#define ESCAPE ’\x1b’ //escape = ASCII(27), octal(33)

//hexadecimal(1b)
main()
{
char caracter;
do
{
printf(”Dame un caracter -> ”);
caracter = getchar();
}
while(caracter != ESCAPE);
}
Sentencia for
Diagrama de Flujo
Ejecución
for(expresión inicial; condición; expresión bucle)
expresión inicial {
expresión(es)
}
falso
¿condición?
expresión bucle
verdadero
Ejemplo
#include <stdio.h>
expresión(es)
main()
{
int i;
for(i = 0; i < 10; i++)

{
printf(”Número -> %5d Cuadrado -> %5d\n”,
i, i * i);
}
}
Sentencias break, continue
¾ break: permiten la salida del bucle sin tener en cuenta la expresión que lo controla
¾ continue: permiten la vuelta a la cabecera del bucle sin ejecutar las sentencias restantes
Ejemplo break Ejemplo continue

#include <stdio.h> #include <stdio.h>
main() main()
{ {
char car; char car;
while((car = getchar()) != ’X’) while((car = getchar()) != ’X’)

{ {
if(car == ’\x1b’) if(car == ’\x1b’)
{ {
break; continue;
} }
printf(”Has introducido %c\n”, car); printf(”Has introducido %c\n”, car);
} }
} }
#include <stdio.h> Solución estructurada #include <stdio.h>

Solución estructurada
main()
main() {
{ char car;
char car;
while((car = getchar()) != ’X)
while((car = getchar()) != ’X’ && {
if(car != ’\x1b’)
ccar != ’\x1b’) {
{ printf(”Has introducido %c\n”, car);
printf(”Has introducido %c\n”, car); }
} }
} }
Sentencias break, continue – Ejemplo
Ejemplo break/continue Solución estructurada

main() main()
{ {
int i; int i;
for(i = 0; i < 100; i++) for(i = 0;

{ (i < 100) && (i % 17 != 0);
if(i % 2 == 0) i++)
{ {
continue; // comienza la iteración if(i % 2 != 0)
} {
printf(”Nuestro número es %d\n”, i);
if(i % 17 == 0) }
{ }
break; // sale del bucle }
}
printf(”Nuestro número es %d\n”, i);

}
}
Sentencias Repetitivas Anidadas
Ejemplo de Ejecución
for(expresión inicial; condición1; expresión bucle)
{
while(condición2)
{
expresión(es) while condición 2
for(expresión inicial;
condición3;
expresión bucle)
{
expresión(es) for condición 3
do
{
expresión(es) do..while condición 4
}
while(condición4)
}
}
expresión(es) for condición 1

}
Sentencias Repetitivas Anidadas – Ejemplo

Ejemplo Enunciado
#include <stdio.h> Generar un triángulo de asteriscos, indicando el
número de asteriscos en la base:
main()
{ *
int base, linea, columna; **
***
printf(”Número de asteriscos en base -> ”); ****
scanf(”%d”, &base); *****
linea = 0;
while(linea < base)

Ejemplo
{ #include <stdio.h>
for(columna = 0;
columna < linea; main()
columna++) {
{ int base, linea, columna;
printf(”*”);
} printf(”Número de asteriscos en base -> ”);
scanf(”%d”, &base);
printf(”\n”);
linea++; for(linea = 0; linea < base; linea++)
} {
} for(columna = 0; columna < linea; columna++)
{
printf(”*”);
}
Nota printf(”\n”);
Los dos ejemplos expuestos son equivalentes }
}
Funciones
Subrutinas
9 Procedimientos: son módulos de programa que no ofrecen ningún tipo de valor asociado al
nombre de la subrutina
9 Funciones: son módulos de programa que ofrecen un valor asociado al nombre de la subrutina
Función
Parte de código independiente, que puede ser llamada enviándole unos datos (o sin enviarle nada),
para que realice una determinada tarea y/o proporcione unos resultados
Definición, Declaración y Llamada de una Función

9 Definición: cuerpo de la función en donde reside el código de la misma.
9 Declaración: presentación de la función donde se expresa su nombre, parámetros y tipo de valor
devuelto.
9 Llamada: utilización de la función desde un punto de programa referenciada por su nombre,
indicando el valor de los parámetros de trabajo y utilización del valor devuelto.
Parámetros Formales vs. Parámetros Actuales

9 Parámetros Formales: lista de declaraciones de variables, precedidas por su tipo correspondiente
y separadas por comas (,) declarados en el encabezamiento de la función.
9 Parámetros Actuales: lista de constantes, variables y expresiones de un tipo determinado, que
aparecen en la llamada a una función.
Funciones – Uso de una Función

Una función se invoca provocando valores a los argumentos de la llamada.
9 Los argumentos se pasan siempre por valor
9 El valor se devuelve por medio de la sentencia return()
9 Los procedimientos son funciones de tipo void
9 El control del número y tipo de argumentos es mínimo
9 Las funciones en C permiten recursividad y reentrabilidad
Ejemplo declaración
#include <stdio.h>
int factorial(int numero)
int factorial(int numero); {
int i, out;
main()
{ for(i = 1, out = 1; i <= numero; i++)
int factor; out *= i;
printf("Introduzca un número -> "); return out;

scanf("%d", &factor); }
printf("El factorial de %d es %d\n",

factor, factorial(factor));
} definición
llamada
Funciones – Definición de una Función
Definición de una Función
Consiste en la definición del código necesario para que ésta realice las tareas para las que ha sido
prevista. La definición de una función se debe realizar en alguno de los ficheros que forman parte del
programa.
La primera línea recibe el nombre de encabezamiento (header) y el resto de la definición –encerrado

entre llaves– es el cuerpo (body) de la función.
Formato General
[clase] [tipo] nombre_funcion([lista de argumentos con tipos])
{
[declaración de variables y/o de otras funciones]
codigo ejecutable // sentencias
return (expresión); // optativo
}
9 clase: define el ámbito de la función, esto es, desde dónde puede ser llamada. La clase puede ser
extern o static.
9 tipo: indica el tipo de valor devuelto por la función.
9 nombre: es el identificador que indica el nombre de la función.
9 lista de argumentos: secuencia de declaración de parámetros separados por comas y encerrados
entre paréntesis. Son los llamados parámetros formales.
Funciones – Declaración de una Función

Declaración de una Función
Toda función debe ser declarada antes de ser utilizada en la función o programa que realiza la
llamada.
Formas de Declarar una Función

9 Mediante una llamada a la función: Se supone int como tipo del valor de retorno, y el tipo de los
argumentos actuales como tipo de los argumentos formales
9 Mediante una definición previa de la función
9 Mediante una declaración explícita, previa a la llamada
Formato General
[clase] [tipo] nombre_funcion([lista de tipos de argumentos]);
Ejemplo
int factorial(int numero);
int factorial(int);
int factorial();
Funciones – Llamada de una Función
Llamada de una Función
La llamada a una función se hace incluyendo su nombre en una expresión o sentencia del programa
principal o de otra función. Este nombre puede ir seguido de una lista de argumentos separados por
comas y encerrados entre paréntesis, los parámetros actuales.
Cuando se llama a una función se ejecuta el código correspondiente a la función hasta que se llega a
una sentencia return o al final del cuerpo de la función, y entonces se devuelve el control al
programa que realizó la llamada, junto con el valor de retorno si es que existe.
Formato General
variable = expresión([parámetros actuales]);
9 variable: especifica la variable en donde va a ser almacenado el valor devuelto por la función. La
llamada puede prescindir del valor devuelto por la función.
9 expresión: especifica la dirección que referencia a la función. En general se corresponde con el
nombre de la función.
9 parámetros actuales: lista de expresiones separadas por comas. Las expresiones son evaluadas,
pasadas a la función y asignadas a los parámetros formales. El número de parámetros actuales
coincide con el parámetros formales, a no ser que especifique un número variable de parámetros.
Funciones – Ejemplos
Ejemplo Cálculo de una expresión absoluta
#include <stdio.h>
double valor_abs(double); /* declaración */
void main (void)

{ Ejemplo Cálculo de un logaritmo
double z, y; #include <stdio.h>
#include <math.h>
y = -30.8;
z = valor_abs(y) + y * y; /* llamada en double logaritmo(float numero, int base);
una expresión */
void main (void)
printf("El valor calculado es %g\n", z); {
} float numero;
int base;
double valor_abs(double x)
{ printf("Introduce un número -> ");
if (x < 0.0) scanf("%f", &numero);
return -x; printf("Introduce la base -> ");
else scanf("%d", &base);
return x;
} printf("El logaritmo de %lg es %lg\n",
numero, logaritmo(numero, base));
}
double logaritmo(float numero, int base)

{
return log(numero)/log(base);
}
Funciones – Paso por Referencia
Paso por Referencia
El lenguaje C no tiene en si en paso por referencia. En su lugar se pasa por valor la dirección de la
variable a modificar. Pero por correspondencia con los diferentes textos, llamaremos a este paso por
dirección paso por referencia.
Ejemplo Permutar dos Números Ejemplo Permutar dos Números

#include <stdio.h> Incorrecto #include <stdio.h> Correcto
void permutar(double, double); void permutar(double *, double *);
main() main()
{ {
double a=1.0, b=2.0; double a=1.0, b=2.0;
printf("a = %lf, b = %lf\n", a, b); printf("a = %lf, b = %lf\n", a, b);

permutar(a, b); permutar(&a, &b);
printf("a = %lf, b = %lf\n", a, b); printf("a = %lf, b = %lf\n", a, b);
} }
void permutar(double x, double y) void permutar(double *x, double *y)

{ {
double temp; a = 1.000000, b = 2.000000 double temp;
a = 1.000000, b = 2.000000
temp = x; temp = *x;
x = y; Soluciones *x = *y;
y = temp; a = 1.000000, b = 2.000000 *y = temp;
} a = 2.000000, b = 1.000000 }
Funciones – La Función main con Argumentos

Argumentos de la Función main
9 argc: es una variable int que contiene el número de palabras que se teclean a continuación del
nombre del programa cuando éste se ejecuta.
9 argv: es un vector de punteros a carácter que contiene las direcciones de la primera letra o
carácter de dichas palabras.
Prototipo de la Función main

int main(int argc, char *argv[]);
Ejemplo Mostrar Argumentos de Entrada

#include <stdio.h>
int main(int argc, char *argv[])

{
int cont;
for (cont=0; cont<argc; cont++)

printf("El argumento %d es: %s\n", cont, argv[cont]);
printf("\n");
return 0;
}
Funciones – Funciones de Librería Estándar I
Funciones de Conversión de Datos <stdlib.h>
¾ double atof (char *cadena);
Convierte una cadena a valor real doble
¾ int atoi (char *cadena);

Convierte una cadena a entero
¾ long atol (char *cadena);

Convierte una cadena a entero largo
¾ char *fcvt (double valor, int decs, int *pdec, int *signo);
Convierte un número real en una cadena de caracteres.
Funciones de Conversión de Caracteres <ctype.h>

¾ int toascii (int numero);
Convierte un número a un valor ASCII.
¾ int tolower (int caracter);

Convierte un carácter a minúscula, si procede.
¾ int toupper (int caracter);

Convierte un carácter a mayúscula, si procede.
Funciones – Funciones de Librería Estándar II

Funciones Matemáticas <math.h>
¾ double ceil (double valor);
Redondea un número real al menor entero que es mayor que el valor parámetro
¾ double floor (double valor);

Redondea un número real al mayor entero que es menor que el valor parámetro
¾ int abs (int valor);

Calcula el valor absoluto del valor parámetro entero
¾ double fabs (double valor);

Calcula el valor absoluto del valor parámetro real
¾ double fmod (double dividendo, double divisor);

Calcula el resto de la división dividendo/divisor
¾ double sqrt (double valor);

Devuelve la raíz cuadrada del parámetro valor
¾ double pow (double base, double exponente);

Calcula la potencia base elevado a exponente
Funciones – Funciones de Librería Estándar III
Funciones Matemáticas Exponenciales <math.h>
¾ double exp (double valor);
Devuelve el valor exponencial para el parámetro valor
¾ double log (double valor);

Devuelve el logaritmo neperiano del parámetro valor
¾ double log10 (double valor);

Devuelve el logaritmo base 10 del parámetro valor
Funciones Matemáticas Trigonométricas <math.h>

¾ double sin (double valor); ¾ double asin (double valor);
Devuelve el seno para el parámetro valor Devuelve el arco seno para el parámetro valor
¾ double cos (double valor); ¾ double cos (double valor);

Devuelve el coseno del parámetro valor Devuelve el arco coseno del parámetro valor
¾ double tan (double valor); ¾ double tan (double valor);

Devuelve la tangente del parámetro valor Devuelve el arco tangente del parámetro valor
Funciones – Funciones de Librería Estándar IV

Funciones Aleatorias <stdlib.h>
¾ int rand (void);
Devuelve un número entero pseudoaleatorio
¾ void srand (unsigned int semilla);

Establece el comienzo de generación de números pseudoaleatorios
Ejemplo
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
int i;
srand((unsigned int) time(NULL));
for(i = 0; i < 5; i++)

{
printf("Aleatorio[%d] = %d\n", i, rand());
}
}
Ámbito y Duración de Variables
Ámbito de las Variables

La declaración de las variables lleva asociado un ámbito, dentro del cual la variable es visible:
¾ Ámbito Global: Las variables son visibles en todas las funciones del programa. Se declaran al
principio de módulo.
¾ Ámbito Local: Las variables son visibles dentro del bloque o función en el que encuentra
definida. (Tiene prioridad sobre el ámbito global)
Duración de las Variables

¾ Permanente: Se crean al comienzo de programa y permanecen hasta el final.
¾ Volátil: Su duraciones están unidas con las de las ejecuciones de los bloques en las que están
definidas.
Almacenamiento de Variables
Métodos de Almacenamiento
¾ Auto: Método de almacenamiento por defecto, se crean sobre la pila de programa. Se crean al
comenzar a ejecutarse el bloque y dejan de existir cuando el bloque se termina de ejecutar. Son
variables locales. No son inicializadas por defecto.
¾ Extern: Se definen fuera de cualquier bloque o función. Son variables globales. Por defecto, son
inicializadas a cero. Para utilizarlas en otros módulos deben ser declaradas como extern.
¾ Static: Conservan su valor entre distintas ejecuciones del bloque en que están definidas. Por
defecto, son inicializadas a cero. Las variables definidas como static extern son visibles sólo
para las funciones y bloques comprendidos desde su definición hasta el fin del fichero. Una
función puede también ser definida como static, y entonces sólo es visible para las funciones
que están definidas después de dicha función y en el mismo fichero.
¾ Register: Es un modo de recomendación para el compilador, para que –si es posible– ciertas
variables sean almacenadas en los registros de la CPU y los cálculos con ellas sean más rápidos.
Modo de Almacenamiento Palabra Reservada Duración Ámbito
Automático auto volátil local

Registro register volátil local
Estático static permanente local
Externo extern permanente global
Almacenamiento de Variables – Ejemplo
Ejemplo
#include <stdio.h>
Solución
int var_global = 1;
Main: global = 1, local = 1
Función: global = 2, local = 1, estática = 1
void test_static();
main()
{
int var_local;
for(var_local = 1; var_local <= 3; var_local++)

{
printf(”Main: global = %d, local = %d\n”,
var_global++, var_local);
test_static();
}
}
void test_static(void)
{
int var_local = 1;
static int var_static = 1;
printf(”Función: global = %d, local = %d, estática = %d\n”,

var_global++, var_local++, var_static++);
}
Arrays – Definición e Inicialización
Definición
Para definir los arrays es necesario indicar el tipo de datos se quiere almacenar en el array, el nombre
del array y la cantidad de elementos
int numeros [30]; /* un array para guardar 30 números enteros */

char alfabeto [26]; /* un array para guardar 26 caracteres */
long largos [500]; /* un array para guardar 500 números enteros
tipo long */
float temp_semana [7]; /* un array para guardar 7 números reales */
Inicialización
Los arrays se pueden inicializar directamente en la definición.
int numeros[3] = {2, 7, 11};

float temp[7] = {12.3, 13.4, 11.7, 10.2, 9.1, 10.8, 11.0};
char cadena[10] = {’A’, ’n’, ’o’, ’n’, ’i’, ’m’, ’o’, ’\0’};
Arrays – Indexación
Indexación
¾ Para identificar cada elemento de un array se utiliza un número denominado índice.
¾ El índice obligatoriamente debe ser un número entero.
¾ El valor del índice correspondiente al primer elemento es 0.
int a[6];
a[0] = 23;
a[2] = a[0] + 5; a 23 28
a[0] a[1] a[2] a[3] a[4] a[5]
for(i=0; i < 6; i++)
{
printf(”%d”, a[i]);
}
Ejemplo Solución
#include <stdio.h> el mes 1 tiene 31 días.
el mes 2 tiene 28 días.
#define MESES 12 el mes 3 tiene 31 días.
...
void main (void) el mes 11 tiene 30 días.
{ el mes 12 tiene 31 días.
int cont = 0;
static int meses[MESES] = {3l,28,3l,30,31,30,3l,31,30,3l,30,31};
for (cont = 0; cont < MESES; cont++)
{
printf ( "el mes %2d tiene %2d días\n", cont + l, meses[cont]);
}
}
Arrays – Arrays Multidimensionales

Definición
¾ Es posible declarar arrays de varias dimensiones. Por cada dimensión habrá un índice.
¾ Mientras que los arrays de una dimensión pueden asemejarse a vectores, los arrays de dos
dimensiones se pueden asemejar a matrices.
foat matriz[10]10];
static float lluvia[4][12] =

{
{10.2,4.1,12.2,2.4,7.7,6.8,7.0,8.7,11.5,8.3,4.7,9.2},
{11.2,10.1,11.2,6.4,7.9,9.3,9.0,8.7,11.5,8.3,4.7,9.2},
{13.2,8.6,12.3,3.4,7.8,9.8,8.0,8.7,11.5,8.3,4.7,9.2},
{1.2,8.9,42.2,9.4,7.8,4.8,10.0,8.7,11.5,8.3,4.7,9.2},
};
static int tres_dimen[3][2][4] =

{
{
{1, 2, 3, 4},
{5, 6, 7, 8}
},
{
{7, 9, 3, 2},
{4, 6, 8, 3}
},
{
{7, 5, 6, 8},
{0, 1, 9, 4}
}
};
Arrays – Arrays y Punteros
Definición
¾ Un puntero puede referenciar un array o elemento de un array.
¾ El nombre de un array es la dirección del mismo array.
int meses[12] ;
meses == &meses[0];
Ejemplo
#include <stdio.h>
void main (void)

Ejemplo {
static int fechas [4] = {10, 20, 30, 40};
#include <stdio.h> int i;
void main (void) for (i = 0; i < 4; i++)

{ {
static int fechas [4] = {10, 20, 30, 40}; printf ("fechas [%d] = %d, dirección: %lu\n",
int *entero_ptr; i, fechas[i], &fechas[i]);
int i; }
}
entero_ptr = fechas;
for (i = 0; i < 4; i++) Solución

{
printf ("fechas [%d] = %d, dirección: %lu\n", fechas [0] = 10, dirección: 70478
i, *(entero_ptr + i), (entero_ptr + i)); fechas [1] = 20, dirección: 70480
} fechas [2] = 30, dirección: 70482
} fechas [3] = 40, dirección: 70484
Arrays – Arrays y Funciones

Ejemplo
#include <stdio.h> void inicializa(int lista [], int *cuanto)
{
#define CANTIDAD 20 int i;
void inicializa (int lista [], int *cuanto); for (i = 0; i < CANTIDAD; i++)
int el_mayor (int lista [], int cuanto); {
printf("Introduzca el número[%d]: ", i);
void main (void) scanf("%d", &lista[i]);
{ }
int lista[CANTIDAD];
int longitud, num; *cuanto = CANTIDAD;
}
inicializa(lista, &longitud);
num = el_mayor(lista, longitud); int el_mayor(int lista[], int cuanto)
{
printf("El mayor número introducido es: %d\n", int mayor, i;
num);
} mayor = lista[0];
for (i = l; i < cuanto; i++)

{
if (mayor < lista[i])
{
mayor = lista[i];
}
}
return (mayor);
}
Strings – Cadenas de Caracteres
Definición
Las cadenas de caracteres son un tipo de arrays especiales cuya función principal es la manipulación
de caracteres.
Una cadena de caracteres o un string, es un array formado por caracteres que tiene al final un
carácter especial: '\0'.
Los strings son arrays que almacena datos tipo char y como tales se declaran:
char cadenadecaracteres [20] = "Esto es una cadena de caracteres";
¾ Pueden inicializarse mediante una constante tipo string.

¾ No es necesario saber la longitud, para detectar él final basta con buscar el carácter '\0'.
¾ Se encuentran formatos especiales para las cadenas (printf, scanf).
¾ Se dispone en la librería estándar de un grupo de funciones específicas para procesar cadenas de
caracteres.
Inicialización
La inicialización de una cadena de caracteres puede hacerse de la siguiente manera:
char animales[] = {'g', 'a', 't', 'o', '\0'};

char animales[] = "gato";
char animales[10] = "gato";
char *animales = "gato";
animales = "gato"; // error de compilación
Strings – Funciones de Librería Estándar

Funciones de Lectura y Escritura <stdio.h>
¾ char *gets (char *cadena);
Lee una línea desde la entrada estándar (stdin) y la almacena en la variable especificada
¾ int puts (char *cadena);

Escribe una cadena en la salida estándar (stdout)
Funciones de Manipulación <string.h>

¾ int strlen (char *cadena);
Devuelve la longitud en bytes de la cadena parámetro.
¾ int strcmp (char *cadena1, char *cadena2);

Compara cadena1 y cadena2, y devuelve 0 si son iguales <0 si cadena1<cadena2 y >0 al contrario
¾ char *strcpy (char *destino, char *origen);

Copia la cadena origen en la posición de la cadena destino.
¾ char *strcat (char *destino, char *origen);

Añade la cadena origen en tras la cadena destino.
¾ char *strchr (char *cadena, char caracter);

Devuelve un puntero a la primera ocurrencia del carácter en la cadena. NULL si no se encuentra.
¾ char *strstr (char *cadena1, char *cadena2);

Devuelve un puntero a la primera ocurrencia de cadena2 en la cadena1. NULL si no se encuentra.
Estructuras – Definición, Declaración e Inicialización
Definición
Es un tipo de datos complejo conformado por un conjunto de campos de otros tipos (básicos o
complejos) asociados a un identificador.
struct [etiqueta]
{
tipo campo1;
tipo campo2;
...
} [variable];
Declaración del Tipo

Cuando realizamos la declaración de tipo de la estructura también es posible definir variables que
van a almacenar ese nuevo tipo de dato .
struct tsagente
{
char nombre[100];
int numero;
} agente, agentes[10];
Declaración e Inicialización de Variables

Las variables de tipo estructuras se pueden inicializar en su declaración.
struct tsagente agente1 = {"Mortadelo", 001};

struct tsagente agente2 = {"Filemón", 002};
Estructuras – Acceso, Asignación y Parámetro de Funciones

Acceso a los Campos
¾ Variable normal: se utiliza el operador punto (•).
¾ Variable puntero: se utiliza el operador flecha (->).
struct tsagente strcpy(agente.nombre, ”Mortadelo”);

{ agente.numero = 001;
char nombre[100];
int numero; pagente = &agente;
} agente, *pagente;
printf(“Nombre: %10s Numero :%3d\n”,
pagente->nombre, pagente->numero);
Asignación de Estructuras
Es posible la asignación directa entre estructuras.
struct tsagente agente1, agente2 = {”Mortadelo”, 001};
agente1 = agente2;
Las Estructuras como Parámetro de Funciones

Las estructuras de datos son tipos complejos y (aunque ciertos compiladores lo admiten) no deben
ser pasados como argumentos, ni devueltos por funciones. En su lugar se usan punteros a dichas
estructuras.
struct tsagente *leer_agente();

void mostrar_agente(struct tsagente *agente);
Estructuras – Anidación y Arrays de Estructuras
Anidación de Estructuras
Los campos de las estructuras pueden ser otras estructuras.
struct tspersona struct tsagente

{ {
char nombre[100]; struct tspersona persona;
int numero; struct tsagencia agencia;
}; };
struct tsagencia struct tsagente agente;

{
char nombre[100]; strcpy(agente.persona.nombre, ”Mortadelo”);
char pais[30]; strcpy(agente.agencia.nombre, ”TIA”);
};
Arrays de Estructuras
Los componentes de un array pueden ser estructuras.
struct tsagente agentes[10];
strcpy(agentes[0].persona.nombre, ”Mortadelo”);
agentes[0].persona.numero = 001;
Ficheros – Concepto y Tipos

Concepto
El concepto de fichero en el lenguaje C es general; se incluyen en él tanto dispositivos (pantalla,
impresora, teclado), cómo ficheros que se almacenan en memoria.
Tipos de E/S de Ficheros

¾ entrada/salida estándar (standard I/O).
¾ entrada/salida a nivel de sistema (system-level I/O) .
Tipos de Ficheros de Datos

¾ Ficheros de Texto: Datos se encuentran estructurados en modo texto. Contienen caracteres ASCII.
¾ Ficheros Binarios: Datos en formato de almacenamiento en memoria. Contienen todo tipo de datos.
Formas de Leer y Escribir Datos en Ficheros

¾ Modo carácter: Los datos se leen y escriben carácter a carácter.
¾ Modo cadena: Los datos se leen y escriben como cadenas de caracteres.
¾ Modo formateado: Los datos se leen y escriben en modo formato.
¾ Modo bloque: Se utiliza para leer y escribir una cantidad fija de datos.
Ficheros – Apertura de Fichero
Apertura de un fichero
Para acceder a un fichero es necesario abrirlo.
Al abrir el fichero la información de control de acceso al fichero se guarda en una estructura

denominada FILE (definida en el fichero stdio.h) y que se utiliza mediante un puntero.
FILE *fopen(char *nombre, char *modo);
9 nombre: nombre del fichero con su path correspondiente

9 modo: modo de apertura del fichero.
Modo Operaciones admitidas
r Lecturas
w escrituras (crea fichero o lo sobrescribe)
a escritura en el final del fichero (de no haber fichero lo crea)
r+ lecturas + escrituras (fichero creado)
w+ lecturas + escrituras (crea fichero o lo sobrescribe)
a+ lecturas + escrituras a final de fichero (de no haber fichero lo crea)
Al modo de apertura hace falta añadir si se abre en modo texto (t) o en modo binario (b).
La función devuelve el puntero al fichero abierto. Si se produce un error en la apertura devuelve un

puntero nulo (NULL).
FILE *fich;
fich = fopen(“\\ejemplos\\texto. txt", "w");
Ficheros – Cierre y Fin de Fichero

Cierre de un fichero <stdio.h>
Todo fichero abierto debe ser cerrado.
int fclose(FILE *fichero);
Fin de un fichero <stdio.h>

int feof(FILE * fichero);
Devuelve un valor distinto de cero si no se encuentra al final de fichero (EOF).
Ejemplo
#include <stdio.h>
void main (void)

{
FILE *fich;
if((fich = fopen("texto.txt", "r")) != (FILE *) NULL)

{
printf("El fichero \"texto.txt\" puede abrirse.\n");
fclose(fichero_ptr);
}
else
{
printf("El fichero \"texto.txt\" no puede abrirse.\n");
}
}
Ficheros – E/S Carácter a Carácter
Funciones de E/S Carácter a Caracter <stdio.h>
¾ int fputc (int caracter, FILE *fichero);
Introduce un carácter en el fichero.
¾ int fgetc (FILE *fichero);

Leer un carácter del fichero.
Ejemplo
#include <stdio. h>
void main (void)

{
FILE *fich;
char caracter;
if((fich = fopen("texto.txt ", "r")) != (FILE *) NULL)

{
while ((caracter = fgetc(fich)) != EOF)
{
printf("%c", caracter);
}
fclose(fich);
}
else
{
printf("\nEl fichero \"texto.txt\" no puede abrirse.");
}
}
Ficheros – E/S en Modo Cadena

Funciones de E/S de Cadenas de Caracteres <stdio.h>
¾ int fputs (char *cadena, FILE *fichero);
Introduce una cardena en el fichero.
¾ char *fgets (char *cadena, int longitud, FILE *fichero);

Lee una cadena de caracteres de un fichero de cómo máximo longitud – 1 caracteres.
Ejemplo
#include <stdio.h>
#define CARACTERES 100
void main (void)

{
FILE *fich;
char cadena[CARACTERES];
if((fich = fopen ("texto.txt", "r")) != (FILE *)NULL)

{
while (fgets(cadena, CARACTERES, fich) != (char *)NULL)
{
printf ("%s", cadena);
}
fclose (fich);
}
else
{
printf("\nEl fichero \"texto.txt\" no puede abrirse.");
}
}
Ficheros – E/S en Modo Formateado
Funciones de E/S con Formato <stdio.h>
¾ int fprintf (FILE *fichero, char *formato[,arg]…);
Escribe los argumentos en el formato especificado en el fichero.
¾ int fscanf (FILE *fichero, char *formato[,arg]…);

Lee los argumentos en el formato especificado del fichero.
Ejemplo
#include <stdio.h>
#include <string.h>
void main (void)

{
FILE *fich;
char nombre[CARACTERES];
int codigo;
float longitud;
if((fich = fopen("texto.txt", "r")) != (FILE *)NULL)

{
while(fscanf (fich, "%s %d %f", nombre, &codigo, &longitud) != EOF)
{
printf("\n%10s %10d %10.2f", nombre, codigo, longitud);
}
fclose (fich);
}
else
{
printf ("n\El fichero \"texto.txt\" no puede abrirse");
}
}
Ficheros – E/S en Modo Bloque

Funciones de E/S Utilizando Registros o Bloques <stdio.h>
¾ size_t fwrite (void *buffer, size_t tamanio, size_t numero, FILE *fichero);
Escribe un buffer de numero de elementos de un tamaño en el fichero.
¾ size_t fread (void *buffer, size_t tamanio, size_t numero, FILE *fichero);
Lee un buffer de numero de elementos de un tamaño del fichero.
Ejemplo
#include <stdio.h>
fclose (fich);
}
else
{
struct tspieza
printf ( "\nEl fichero piezas.dat no puede abrirse");
{
}
char nombre[CARACTERES];
}
int numero;
float peso;
};
void main (void)

{
struct tspieza pieza;
FILE *fich;
if((fich = fopen("piezas.dat", "rb")) != (FILE *)NULL)

{
while(fread(&pieza, sizeof (struct tspieza), 1, fich) == 1)
{
printf("\nNombre : %s", pieza.nombre);
printf("\nNúmero : %d", pieza.numero);
printf("\nPeso : %f", pieza.peso);
}
Ficheros – Acceso Aleatorio a un Fichero
Funciones de Acceso Aleatorio a un Fichero <stdio.h>
¾ int fseek(FILE *fichero, long offset, int modo);
Posiciona el puntero interno del fichero. Modo Offset Definición
0 Desde el comienzo del fichero SEEK_SET
1 Desde la posición actual SEEK_CUR
2 Desde el final de fichero SEEK_END
¾ int ftell(FILE *fichero);

Devuelve la posición relativa respecto del comienzo de fichero mediante un número entero.
¾ void rewind(FILE *fichero);

Coloca el puntero de fichero al comienzo del mismo, desactivando errores y fin de fichero.
Ejemplo
#include <stdio.h>
else
{
void main (void)
printf ("n\El fichero \"datos.dat\" no puede abrirse");
{
}
FILE *fich;
}
int posicion;
if((fich = fopen("datos.dat", "rb")) != (FILE *)NULL)

{
fseek(fich, 0L, SEEK_END); // ó fseek(fich, 0L, 2); Coloca al final de fichero
rewind(fich); // Coloca al principio de fichero
posicion = ftell(fich); // La posición se cooresponde con el inicio de fichero
fclose (fich);
}
Ficheros – Ejemplo 1
Ejemplo 1 Paso 1 Ejemplo 1 Paso 3
void main(void) void main(void)

{ {
char nombre[100]; char nombre[100];
int entero; int entero;
float real; float real;
FILE *fich;
printf("Dame un nombre un entero y un real\n");
scanf("%s %d %f", nombre, &entero, &real); fich = fopen("fichero.txt", "rt");
printf("Nombre = %s, entero = %d, real = %f\n",
nombre, entero, real); if(fich != (FILE *) NULL)
} {
fscanf(fich, "%s %d %f", nombre, &entero, &real);
printf("Nombre = %s, entero = %d, real = %f\n",
nombre, entero, real);
fclose(fich);
}
else
Ejemplo 1 Paso 2 {
printf("No se puede abrir fichero\n");
}
#include <stdio.h>
}
void main(void)
{
char nombre[100]; if(fich != (FILE *) NULL)
int entero; {
float real; fprintf(fich, "%s %d %f", nombre, entero, real);
FILE *fich; fclose(fich);
}
printf("Dame un nombre un entero y un real\n"); else
scanf("%s %d %f", nombre, &entero, &real); {
printf("No se puede crear fichero\n");
fich = fopen("fichero.txt", "wt"); }
}
Ficheros – Ejemplos 2 y 3 Paso 1 (Programa Principal)
Declaraciones, Tipos y Programa Principal
#include <stdio.h>
#define MAXARRAY 100
struct rgarticulo
{
char nombre[100];
int unidades;
float precio;
};
void leer_array(struct rgarticulo articulos[], int *longitud);

void mostrar_array(struct rgarticulo articulos[], int longitud);
void leer_registro(struct rgarticulo *articulo);
void mostrar_registro(struct rgarticulo *articulo);
void main(void)
{
struct rgarticulo articulos[MAXARRAY];
int longitud = 0;
leer_array(articulos, &longitud);
mostrar_array(articulos, longitud);
}
Ficheros – Ejemplos 2 y 3 (Funciones varias)

Función leer_array
void leer_array(struct rgarticulo articulos[], int *longitud)
{
char opcion;
Función leer_registro
do
void leer_registro(struct rgarticulo *articulo)
{
{
printf("Introducir elemento [s/n]? ");
struct rgarticulo articulin;
opcion = getchar();
if(opcion == 'S' || opcion == 's')
printf("Nombre : ");
{
scanf("%s", articulin.nombre);
leer_registro(&articulos[*longitud]);
printf("Unidades : ");
(*longitud)++;
scanf("%d", &articulin.unidades);
}
printf("Precio : ");
} while (opcion != 'N' && opcion != 'n');
scanf("%f", &articulin.precio);
}
*articulo = articulin;
}
Función mostrar_array
void mostrar_array(struct rgarticulo articulos[], int longitud)
{
int i;
for(i = 0; i < longitud; i++)

{ Función mostrar_registro
printf("\nRegistro %d\n", i + 1);
void mostrar_registro(struct rgarticulo *articulo)
mostrar_registro(&articulos[i]);
{
}
printf("Nombre : %s\n", articulo->nombre);
}
printf("Unidades : %d\n", articulo->unidades);
printf("Precio : %f\n", articulo->precio);
}
Ficheros – Ejemplo 2 Paso 2 (E/S Modo Formateado)
Declaraciones, Tipos
y Programa Principal
#include <stdio.h>

#define NOMFICH "Articuls.txt"
struct rgarticulo Función array_fichero

{
char nombre[100]; void array_fichero(char *nomfich,
int unidades; struct rgarticulo articulos[],
float precio; int longitud)
}; {
int i;
void leer_array(struct rgarticulo articulos[], FILE *fich;
int *longitud);
void leer_registro(struct rgarticulo *articulo); if((fich = fopen(nomfich, "wt")) != (FILE *) NULL)
void array_fichero(char *nomfich, {
struct rgarticulo articulos[], for(i = 0; i < longitud; i++)
int longitud); {
fprintf(fich, "%s %d %f\n",
void main(void) articulos[i].nombre,
{ articulos[i].unidades,
struct rgarticulo articulos[MAXARRAY]; articulos[i].precio);
int longitud = 0; }
fclose(fich);
leer_array(articulos, &longitud); }
array_fichero(NOMFICH, articulos, longitud); else
} {
printf("No se ha podido crear el fichero %s\n",
nomfich);
}
}

#include <stdio.h>

#define NOMFICH "Articuls.txt"
struct rgarticulo Función fichero_array

{
char nombre[100]; void fichero_array(char *nomfich,
float precio; int *longitud)
}; {
struct rgarticulo articulin;
void mostrar_array(struct rgarticulo articulos[], FILE *fich;
int longitud);
void mostrar_registro(struct rgarticulo *articulo); *longitud = 0;
void fichero_array(char *nomfich,
struct rgarticulo articulos[], if((fich = fopen(nomfich, "rt")) != (FILE *) NULL)
int *longitud); {
while(fscanf(fich, "%s %d %f",
void main(void) articulin.nombre,
{ &articulin.unidades,
struct rgarticulo articulos[MAXARRAY]; &articulin.precio) != EOF)
int longitud = 0; {
articulos[*longitud] = articulin;
fichero_array(NOMFICH, articulos, &longitud); (*longitud)++;
mostrar_array(articulos, longitud); }
} fclose(fich);
}
else
{
printf("No se ha podido abrir el fichero %s\n",
nomfich);
}
}
#include <stdio.h>
#define MAXARRAY 100 Función transformar_array

#define NOMFICH1 "Articuls.txt"
#define NOMFICH2 "Articul2.txt" void transformar_array(struct rgarticulo articulos[],
#define PTSEURO 166.386 int longitud)
{
struct rgarticulo int i;
{
char nombre[100]; for(i = 0; i < longitud; i++)
int unidades; {
float precio; articulos[i].precio = articulos[i].precio / PTSEURO;
}; }
}
void mostrar_array(struct rgarticulo articulos[],
int longitud);
void transformar_array(struct rgarticulo articulos[],
int longitud);
void array_fichero(char *nomfich,
struct rgarticulo articulos[],
int longitud);
int *longitud);
void main(void)
{
int longitud = 0;
fichero_array(NOMFICH1, articulos, &longitud);

transformar_array(articulos, longitud);
array_fichero(NOMFICH2, articulos, longitud);
}
Ficheros – Ejemplo 3 Paso 2 (E/S Modo Bloque)

#include <stdio.h>

#define NOMFICH "Articuls.dat"
struct rgarticulo Función array_fichero

{
char nombre[100]; void array_fichero(char *nomfich,
float precio; int longitud)
}; {
int i;
void leer_array(struct rgarticulo articulos[], FILE *fich;
int *longitud);
void leer_registro(struct rgarticulo *articulo); if((fich = fopen(nomfich, "wb")) != (FILE *) NULL)
void array_fichero(char *nomfich, {
struct rgarticulo articulos[], for(i = 0; i < longitud; i++)
int longitud); {
fwrite(&articulos[i],
void main(void) sizeof(struct rgarticulo),
{ 1,
struct rgarticulo articulos[MAXARRAY]; fich);
int longitud = 0; }
fclose(fich);
leer_array(articulos, &longitud); }
array_fichero(NOMFICH, articulos, longitud); else
} {
printf("No se ha podido crear el fichero %s\n",
nomfich);
}
}
#include <stdio.h>

#define NOMFICH "Articuls.dat"
struct rgarticulo Función fichero_array

{
char nombre[100]; void fichero_array(char *nomfich,
float precio; int *longitud)
}; {
FILE *fich;
int longitud); *longitud = 0;
void fichero_array(char *nomfich, if((fich = fopen(nomfich, "rb")) != (FILE *) NULL)
struct rgarticulo articulos[], {
int *longitud); while(fread(&articulos[*longitud],
sizeof(struct rgarticulo),
void main(void) 1,
{ fich) == 1)
struct rgarticulo articulos[MAXARRAY]; {
int longitud = 0; (*longitud)++;
}
fichero_array(NOMFICH, articulos, &longitud); fclose(fich);
mostrar_array(articulos, longitud); }
} else
{
printf("No se ha podido abrir el fichero %s\n",
nomfich);
}
}

#include <stdio.h>
#define MAXARRAY 100 Función transformar_array

#define NOMFICH1 "Articuls.dat"
#define NOMFICH2 "Articul2.dat" void transformar_array(struct rgarticulo articulos[],
#define PTSEURO 166.386 int longitud)
{
struct rgarticulo int i;
{
char nombre[100]; for(i = 0; i < longitud; i++)
int unidades; {
float precio; articulos[i].precio = articulos[i].precio / PTSEURO;
}; }
}
int longitud);
void transformar_array(struct rgarticulo articulos[],
int longitud);
int longitud);
int *longitud);
void main(void)
{
int longitud = 0;
fichero_array(NOMFICH1, articulos, &longitud);

transformar_array(articulos, longitud);
array_fichero(NOMFICH2, articulos, longitud);
}
Examen Febrero 2001 – 1/2
Declaraciones, Tipos void fichero_array(char *nomfich, struct rgtemp argtemp[], int *tamanio);
void array_fichero(char *nomfich, struct rgtemp argtemp[], int tamanio);
y Programa Principal int existe_fichero(char *nomfich);
void modificacion(float valor, struct rgtemp argtemp[], int tamanio);
#include <stdio.h>
void main(void)
#include <string.h>
{
char nomfichdat[20], nomfichmod[20];
char dia[10], mes[10], anio[10];
struct rgtemp argtemp[MAXARRAY];
struct rgtemp
int tamanio;
{
float valor;
char hora[5];
float temp;
printf("Introduzca el día, mes y año a tratar: ");
};
scanf("%s %s %s", dia, mes, anio);
strcat(strcat(strcat(strcpy(nomfichdat, dia), mes), anio), ".DAT");
if(existe_fichero(nomfichdat))
{
printf("Encontrado fichero %s\n", nomfichdat);
printf("Introduzca el tanto por ciento a aplicar: ");

scanf("%f", &valor);
printf("Procesando información...\n");
fichero_array(nomfichdat, argtemp, &tamanio);
modificacion(valor, argtemp, tamanio);
strcat(strcat(strcat(strcpy(nomfichmod, dia), mes), anio), ".MOD");

array_fichero(nomfichmod, argtemp, tamanio);
printf("Generado fichero %s\n", nomfichdat);

}
else
{
printf("No existe el fichero %s\n", nomfichdat);
}
}
Examen Febrero 2001 – 2/2

Función fichero_array Función array_fichero
void fichero_array(char *nomfich, struct rgtemp argtemp[],
int *tamanio)
struct rgtemp argtemp[],
{
int tamanio)
FILE *fich;
{
struct rgtemp registro;
FILE *fich;
int i;
*tamanio = 0;
if((fich = fopen(nomfich, "w")) != (FILE *) NULL)
if((fich = fopen(nomfich, "r")) != (FILE *) NULL)
{
{
for(i = 0; i < tamanio; i++)
while(fscanf(fich, "%s %f", registro.hora,
{
&registro.temp) != EOF)
fprintf(fich, "%s %g\n",
{
argtemp[i].hora,
argtemp[*tamanio] = registro;
argtemp[i].temp);
(*tamanio)++;
}
}
fclose(fich);
fclose(fich);
}
}
}
}
Función existe_fichero Función modificación

void modificacion(float valor,
int existe_fichero(char *nomfich)
struct rgtemp argtemp[], int tamanio)
{
{
FILE *fich;
int i;
int out = 0;
{
{
if(strcmp(argtemp[i].hora, "1800") >= 0 &&
out = 1;
strcmp(argtemp[i].hora, "2000") <= 0)
fclose(fich);
{
}
argtemp[i].temp *= (1.0 + (valor / 100.0));
}
return out;
}
}
}
Examen Septiembre 2001 – 1/2
Declaraciones, Tipos void fichero_array(char *nomfich, struct rgtemp argtemp[], int *tamanio);
int existe_fichero(char *nomfich);
y Programa Principal float media(int deposito, struct rgtemp argtemp[], int tamanio);
#include <stdio.h> void main(void)

#include <string.h> {
char nomfichdat[20];
#define MAXARRAY 500 char dia[10], mes[10], anio[10];
struct rgtemp argtemp[MAXARRAY];
struct rgtemp int tamanio, deposito;
{
int deposito; printf("Introduzca el día, mes y año a tratar: ");
char hora[5]; scanf("%s %s %s", dia, mes, anio);
float temp;
}; strcat(strcat(strcat(strcpy(nomfichdat, dia), mes), anio), ".DAT");
if(existe_fichero(nomfichdat))
{
printf("Encontrado fichero %s\n", nomfichdat);
printf("Introduzca el número de depósito: ");

scanf("%d", &deposito);
fichero_array(nomfichdat, argtemp, &tamanio);
printf("La temperatura media de depósito %d es: %.3f\n",

deposito,
media(deposito, argtemp, tamanio));
}
else
{
printf("No existe el fichero %s\n", nomfichdat);
}
}
Examen Septiembre 2001 – 2/2

Función fichero_array
void fichero_array(char *nomfich, Función media
float media(int deposito,
int *tamanio)
{
int tamanio)
FILE *fich;
{
struct rgtemp registro;
int i, nummed;
float suma, media, out;
*tamanio = 0;
nummed = 0;
suma = 0.0;
{
out = 0.0;
while(fscanf(fich, "%d %s %f",
&registro.deposito,
registro.hora,
{
&registro.temp) != EOF)
if(argtemp[i].deposito == deposito)
{
{
argtemp[*tamanio] = registro;
suma += argtemp[i].temp;
(*tamanio)++;
nummed++;
}
}
fclose(fich);
}
}
} Función existe_fichero if(nummed > 0)
{
int existe_fichero(char *nomfich)
out = suma / nummed;
{
}
FILE *fich;
int out = 0;
return out;
}
{
out = 1;
fclose(fich);
}
return out;
}
Ejercicios programación en C
Laboratorio de Sistemas
Informáticos
Curso 2003-2004
Isidro Calvo Gordillo

Ejercicios programación en C - Variables y operadores básicos
Variables y operadores básicos
1. Programa que pida un valor en pesetas y lo convierta en euros y otro programa que lleve a cabo la
operación inversa. (Nota 1 euro = 166.386 pts)
Nota: La solución en euros deberá tener 3 decimales.
2. Pedir un carácter por teclado y mostrar un mensaje que muestre el carácter introducido así como su
código ASCII tanto en formato decimal como hexadecimal.
3. Programa que pida la temperatura en grados Celsius y la convierta a grados Fahrenheit (y viceversa)
mostrando en pantalla un mensaje del tipo “xxx.xx grados Celsius son yyy.yy grados Fahrenheit”
F − 32 C
=
9 5
4. Crear un programa que pida el radio de una circunferencia y que calcule la longitud de la misma así
como el área incluida dentro.
5. Crear un programa que calcule la fuerza de atracción gravitacional entre dos masas, M1 y M2
situadas a una distancia R.
M 1* M 2
F =G ( Nw)
R2
donde las masas se expresan en kilogramos y la distancia en metros y la constante de gravitación
universal vale:
G = 6.67 x10 −11 Nw * m 2 / Kg 2
Nota: Utilizar #define para definir la constante G.
6. Escribir un programa que pregunte el año actual y la edad de una persona y calcule la edad de esa
persona en el año 2010.
7. Escribir un programa que calcule el número de billetes de 10.000, 5.000, 1,000, así como de monedas
de 500, 100, 25, 5 y 1 pesetas para desglosar una cantidad, C, de pesetas (menor de 2.147.483.647),
de forma que se necesite la menor cantidad de monedas y billetes de cada tipo.
8. Crear un programa que pida un numero real y muestre la tabla de multiplicar correspondiente a dicho
número de tal manera que tanto los valores de los factores como del producto se presenten
encolumnados y con una precisión de 2 dígitos.
Ejemplo:
Programa que muestra la tabla de multiplicar de un número

Escribe un número: 5 (Valor introducido por el usuario)
TABLA DE MULTIPLICAR DEL NUMERO 5.00
5.00 * 1 = 5.00
5.00 * 2 = 10.00
...
5.00 * 10 = 50.00
9. Mostrar en forma de tabla, el cuadrado y el cubo de los 5 primeros números enteros que siguen a uno
introducido por teclado.
Los datos deben aparecer ajustados a la derecha siguiendo el siguiente formato:
Numero Cuadrado Cubo
Dpto. Ingeniería de Sistemas y Automática UPV/EHU

Ejercicios programación en C - Variables y operadores básicos
------ -------- ----

xxx xxxx xxxxxx
Nota: Ejecutar el programa utilizando variables de tipo int e introduciendo el número base 30 y
utilizando variables de tipo unsigned int e introduciendo el número base 40. ¿Qué sucede? ¿Cómo se
puede explicar lo que sucede?
10. Crear un programa que muestre en pantalla el tamaño en bytes (8 caracteres) de las variables más
frecuentes: char, int, short int, long int, float y double.
(Nota: Para calcular el tamaño de una variable se puede usar el operador sizeof.)
11. Escribir un programa que tras preguntar el número de almacén asociado a un determinado tipo de
pieza, la cantidad pedida de esa pieza y el precio por unidad, efectúe el cálculo del precio total de
las piezas pedidas. El programa deberá escribir toda la información de la pieza en la pantalla, además
del importe total del pedido.
12. Escribir un programa que lea el valor de un ángulo en radianes y muestre su valor en grados, minutos y
segundos
13. Programa que tras pedir por teclado un número lo multiplique por 4 y divida por 2 utilizando los
operadores de rotación.
Dpto. Ingeniería de Sistemas y Automática UPV/EHU

Ejercicios de programación en C - Sentencias condicionales
Sentencias condicionales
1. Ejecutar el siguiente código fuente (Declarando valor_logico como entero y luego declarándolo como
float):
printf(“Valores logicos de las siguientes expresiones\n”);

valor_logico=(3>5);
printf(“(3 > 5) es %d\n”, valor_logico);
valor_logico=(5 > 3);
printf(“(5 > 3) es %d\n”, valor_logico);
valor_logico=(15 > 3*5);
printf(“(15 > 3*5) es %d\n”, valor_logico);
valor_logico=!(5 == 3);
printf(“!(5 == 3) es %d\n”, valor_logico);
Nota: No confundir el operador ‘==’ de comparación (para comprobar si dos valores son iguales)
con el operador ‘=’ de asignación que escribe un valor en una variable.
2. Escribir un programa que tras pedir 2 números por la pantalla muestra cuál es el mayor número.
(Hágase con la sentencia if y con el operador condicional ”expresion?valor1:valor2 )
3. Leer tres números enteros y, si el primero de ellos es negativo, calcular el producto de los tres, en
caso contrario calcular la suma de ellos.
4. Crear un programa que calcule la caída de potencial producida por una resistencia según la ley de
Ohm (V=I*R) a partir de la resistencia y la intensidad que pasa a su través.
Nota: El programa no debe aceptar resistencias negativas, dado que no tienen sentido físico, ni
resistencias mayores que 1000Ω (requerimiento adicional del problema). En ambos casos el
programa debe escribir un mensaje de error en pantalla diciendo que el valor de la resistencia está
fuera de límites aceptables indicando la causa por la que dicho valor para la resistencia ha sido
rechazado.
5. Sea un sistema de ecuaciones de la forma:

ax + by = c
dx + ey = f
que puede resolverse usando las siguientes fórmulas:
ce − bf af − cd
x= y=
ae − bd ae − bd
Escribir un programa que lea los coeficientes (a, b, c, d, e, f) y resuelva el sistema. El programa
deberá indicar los casos en los que el sistema de ecuaciones no tenga solución.
6. Escribir un programa que calcule las raíces, bien reales o imaginarias, de una ecuación de segundo
grado. El programa también debe ser capaz de operar con valores nulos para el coeficiente de orden
dos (Es decir deberá de ser capaz de resolver ecuaciones de primer grado)
En otras palabras, dada la ecuación ax2 + bx + c=0 obtener x1, x2 de forma que:
Si a=0 Ec. 1er grado Raíz única.

Si b2-4ac=0 2 raíces reales iguales
Si b2-4ac > 0 2 raíces reales distintas
Si b2-4ac < 0 2 raíces complejas conjugadas
7. Dada la función U=f(x,y) tal que:
Dpto. Ingeniería de Sistemas y Automática – UPV/EHU

10 si x*y < 1
y2 si x*y ≥ 1
y dada la función V=f(x,y) tal que:
1 si x*y < 1
y2 si x*y ≥ 1
Escribir un programa que calcule los valores de las funciones U y V, una vez conocidas las
coordenadas de un punto (x,y).
8. Escribir un programa que pida un año y diga si es bisiesto o no.
Nota: Un año es bisiesto si es múltiplo de 4 salvo el caso en que sea múltiplo de 100, que no es
bisiesto, y no sea múltiplo de 400. Por ejemplo, el año 1900 no fue bisiesto, el 2000 sí y el 2100 no lo
es.
9. La fecha del Domingo de Pascua está relacionada con el calendario judío que es lunar. Para obtener
en nuestro calendario cuál sería el correspondiente fecha se puede utilizar el siguiente algoritmo a
partir del año para el que se quiere calcular la fecha.
Sea X el año para el que se quiere calcular la fecha.
Sea A el resto de la división de X entre 19

Sea B el resto de la división de X entre 4
Sea C el resto de la división de X entre 7
Sea D el resto de la división de (19*A+24) entre 30
Sea E el resto de la división de (2*B+4*C+6*D+5) entre 7
La fecha para el Domingo de Pascua es el día (22+D+E) de Marzo (obsérvese que puede dar una
fecha en Abril)
Escribir un programa que pida como entrada un año y saque por pantalla la fecha del Domingo de
Pascua para ese año.
10. Leer desde el teclado las coordenadas (x, y) de un punto y, mediante un menú, elegir una entre las
siguientes opciones:
• Comprobar si el punto pertenece a una circunferencia de radio 10 y centro (0,0)

• Averiguar el cuadrante en el que se encuentra el punto.
• Pasar las coordenadas cartesianas (x,y) a polares (r, arg).
• Salir
y r
arg
X
11. Escribir un programa que permita efectuar el cálculo del área de un cuadrado, un círculo o un
triángulo equilátero según la opción seleccionada por el usuario.
• Crear una primera versión con la estructura de control if ... else

• Y una segunda versión con la estructura de control switch... case...
12. Escribir un programa que permita efectuar el cálculo del área de un cuadrado, un círculo o un
triángulo equilátero según la opción seleccionada por el usuario a través de un menú.

13. Dada la longitud de una circunferencia, averiguar si dicha longitud corresponde, con una determinada
precisión, a una circunferencia de radio R.
El programa deberá leer la longitud de la circunferencia, el radio y la precisión e indicará si es cierto

o no que esa circunferencia tiene ese valor del radio.
14. Escribir un programa que pida dos caracteres por pantalla, los ordene alfabéticamente, y los imprima
ordenados.

Ejercicios de programación en C - Sentencias Repetitivas
Sentencias repetitivas
1. Escribir un programa que escriba los números del 1 al 100 en líneas de 10 números. Después de
100 el programa debe escribir “Fin del programa” en una línea nueva.
2. Programa que calcule el valor de elevar un número real, a, a un exponente entero, b, ab,
multiplicando b veces el número a.
Nota: Mejorar el programa para que compruebe que el exponente es mayor que 0 y si no lo es
dar un mensaje de error y pedir otro exponente.
3. Programa que calcule el factorial (n!) de un numero entero positivo leído por teclado.
Nota: Probar el programa con los números 6, 7, 8, 9... ¿Qué pasa a medida que se va
aumentando el número? ¿Por qué?
4. Crear un programa que pida un numero real y muestre la tabla de multiplicar correspondiente a
dicho número de manera que tanto los valores de los factores como del producto se presenten
encolumnados y con una precisión de 2 dígitos.
Ejemplo:
Programa que muestra la tabla de multiplicar de un número

Escribe un número: 5 (Valor introducido por el usuario)
TABLA DE MULTIPLICAR DEL NUMERO 5.00

5.00 * 1 = 5.00
...
5.00 * 10 = 50.00
5. Escribir un programa que calcule el sumatorio:

S
1
∑ (−1)
i =1
i
*
i2
donde S es un número entero positivo introducido por teclado.
Solución: El límite de esa expresión cuando S tiende a infinito es: -0.822467.
6. Programa que escriba en pantalla una tabla con cuadrados y cubos a partir de un número base
hasta otro tope, ambos pedidos por teclado.
Nota: El programa deberá evitar problemas de overflow.
La tabla debe seguir el siguiente formato:
Número Cuadrado Cubo

------ -------- ----
xx xxx xxxx
7. Escribir un programa que ayude a aprender las tablas de multiplicar.
Para ello se irá pidiendo la tabla de multiplicar de un número (pedido por teclado con
anterioridad) y comprobando que los valores introducidos son correctos. Si es así el programa
escribirá “correcto” y en caso contrario deberá escribir “Lo siento, se ha equivocado. La
respuesta correcta era número”
La última línea mostrará el número de aciertos.
A continuación se muestra un ejemplo de ejecución:
Programa para aprender las tablas de multiplicar

Con qué número quieres practicar? 5 (Introducido por el usuario)

5 * 1 = 5 (Introducido por el usuario)
Valor correcto
5 * 2 = 11 (Introducido por el usuario)
Lo siento se ha equivocado. La respuesta correcta era 10
...
Has acertado 9 veces de 10 números.
8. Hacer un programa que lea caracteres desde teclado hasta que lea 10 veces la letra 'a'. Por cada
carácter leído que no sea una 'a' debe mostrar un mensaje indicándolo. Cuando lea las 10 letras 'a' el
programa terminará.
9. Hacer un programa que lea caracteres desde teclado y vaya contando las vocales que aparecen. El
programa terminará cuando lea el carácter # y entonces mostrará un mensaje indicando cuántas
vocales ha leído (cuántas de cada una de ellas).
10. Repetir el ejercicio leyendo caracteres hasta que se lea el carácter final de fichero EOF (^Z) en
lugar del carácter #.
11. Programa que simule que se deja caer una pelota desde un edificio de X metros de altura (donde
X se pide por teclado) mostrando en cada 0.1 segundos tanto la altura de la pelota como su
velocidad.
Mostrar para cada instante de tiempo (cada 0.1 segundos) una línea del estilo:
t=xx.x distancia al suelo=xx.xxx metros velocidad=xx.xxx m/s
12. Programa que calcule los nºs primos del 1 al 100 y los saque por pantalla.
13. Escribir un programa que primero pida por pantalla con cuántos números se va a trabajar
digamos que sean X) y luego pida los X números por pantalla.
Después de introducir los X números se mostrará un mensaje por pantalla indicando cuál es el
mayor y menor valor introducido, así como el valor medio de todos los números introducidos.
14. Programa que pida números de cuatro cifras e indique si los números son capicúas o no. El
programa deberá ir pidiendo números hasta que el usuario introduce ‘-1’ por teclado. El número
–1 indicará la finalización de la ejecución del programa.
Nota1: Un número capicúa es simétrico p.e. 1221 ó 25752

Nota2: Cuando el número no es de cuatro cifras se deberá mostrar un mensaje de error por
pantalla y se pedirá otro número menor que 10000. En caso de que el número sea menor de
cuatro cifras se completará con ceros a la izquierda.
Nota3: El único número negativo que se aceptará es ‘-1’ que indicará la finalización del
programa. Cualquier otro número negativo, se mostrará un mensaje de error.
15. Escribir un programa que calcule los números perfectos entre 1 y 10000.
Nota: Un número perfecto es aquél tal que la suma de sus divisores menos el propio número es
el propio número.
Ej.: 6 ⇒ Divisores(6)={1,2,3,6} Suma = 1+2+3+6 – 6 = 6 ⇒ N.º Perfecto
10 ⇒ Divisores(10)={1,2,5,10} Suma = 1+2+5+10 – 10 ≠ 10 ⇒ N.º no
perfecto
Solución: 6, 28, 496, 8128
16. Escribir un programa que muestre el siguiente menú y que permita pasar magnitudes de grados a
radianes y de radianes a grados.
1. Pasar de grados a radianes

2. Pasar de radianes a grados

3. Salir del programa
17. Escribir un programa que muestre una tabla con los caracteres ASCII mostrados en decimal,
octal y hexadecimal. El programa mostrará la información con el siguiente formato:
Dec: xx Octal: xx Hex: xx Car: x
El programa pedirá el primer y últimos caracteres que marcarán los límites de la tabla.

Ejercicios programación en C - Funciones
Funciones
1. Escribir un programa que permita convertir grados Fahrenheit a Celsius y grados Celsius a
Fahrenheit.
El programa presentará el siguiente menú:
1. Conversión de Celsius a Fahrenheit

2. Conversión de Fahrenheit a Celsius
0. Salir del programa.
Nota: Cada conversión se efectuará por medio de funciones, una que convertirá de grados Celsius a
grados Fahrenheit y otra que haga justo lo contrario.
2. Realizar un programa que escriba todos los números enteros menores que un cierto entero N y que a
su vez sean múltiplos de dos números enteros A y B introducidos por teclado.
Utilizar para ello una función que admita dos parámetros I, J e indique si I es múltiplo de J.
Ej: N=25, A=2, B=3 => 0,6,12,18,24
3. Escribir una función (con su correspondiente programa de prueba) que tome un valor entero y
devuelva el número con sus dígitos en reversa. Por ejemplo, dado el número 7631 la función deberá
devolver 1367.
4. Escribir un programa que calcule masa radioactiva de carbono 14 que queda después de t años. La
fórmula que determina la masa restante en el tiempo t es:
t
 1h
Mt = m* 
 2
donde:
t es el tiempo en años
Mt es la masa que permanece en el tiempo t
m es la masa original
h es la vida media en años
Para el carbono 14 la vida media es de 5700 años; si la masa original es de 300 gramos, imprimir una
tabla de la masa para t=500, 1000, 1500, 2000, ..., 10000 años.
Se deberá utilizar un subprograma que permita evaluar la expresión (1/2)t/h para los diferentes valores
de t.
Nota: En TurboC existe la función double pow(double x, double y) que devuelve el valor xy.
5. Escribir una función que escriba tantas líneas en blanco como se haya pedido con anterioridad al
usuario en el programa principal.
6. Escribir una función que tome el tiempo introducido por el usuario en el formato
(horas:minutos:segundos) y lo convierta en segundos. El programa utilizará esta función para
calcular la diferencia en segundos entre dos tiempos introducidos por el usuario.
7. Escribir un programa que calcule el número combinatorio

M  M!
 =
 N  N ! ( M − N )!
Utilizar para ello una función que calcule el factorial de un número.
Nota: La función para calcular el factorial de un número puede ser iterativa o recursiva. (Una
función recursiva es una función que se llama a sí misma)

8. Escribir una función que calcule el factorial de un número y utilizar ésta en un programa que muestre
el siguiente menú.
1. Factorial de un número
2. Cálculo de e
3. Cálculo de e^x
0. Salir
Nota 1: El cálculo de e debe hacerse con la siguiente expresión matemática:
1 1 1
e = 1+ + + + ...
1! 2! 3!
Sol: e=2.718282
Nota 2: En un entorno de 1 e x puede calcularse mediante la fórmula:
x x2 x3
ex =1+ + + + ...
1! 2! 3!
9. El desarrollo en serie de Taylor de la función coseno entorno al 0 es:

x2 x4 x6
cos ( x) = 1 − + − +...
2! 4! 6!
donde el ángulo x viene expresado en radianes.
Escribir un programa que calcule el valor aproximado de coseno (x), utilizando para ello los N
primeros términos de la serie de Taylor. El número de términos N de la serie dependerá del valor del
último, es decir, se añadirán términos a la serie hasta que el valor absoluto del último término
añadido sea menor que 0.0005.
¿Obtener el coseno de 10 radianes? Compárese con el valor obtenido con la calculadora. ¿Qué
sucede?
10. Se desea realizar un programa que permita hacer cálculos con polinomios de segundo grado.
El programa deberá presentar un menú en pantalla que facilite las siguientes opciones:
1. Leer un polinomio
2. Escribir un polinomio en su forma habitual
3. Evaluar un polinomio en un punto
4. Calcular el polinomio derivado
0. Salir
Se deberán utilizar los siguientes subprogramas:
LEER mediante este subprograma se introducen los números enteros que representan los
coeficientes del polinomio.
ESCRIBIR es un subprograma que permite la escritura de un polinomio en la forma Ax^2
+ Bx + C
Ejemplos válidos: 5x^2+3x+5 5x^2-3x+5 5x^2-5
ejemplos no válidos: 5x^2+ -3x+5 5x^2-0x+5
EVALUAR es un subprograma que retorna el valor de un polinomio para un número real que
es introducido como parámetro.
DERIVAR es un subprograma que calcula el polinomio derivada de uno dado.
Nota: No está permitido el uso de variables globales.
11. Escribir un programa que realice la descomposición en factores primos de un número introducido por
teclado.
El programa deberá ir escribiendo la tabla de los factores primos, a medida que los va calculando, tal
como muestra el ejemplo siguiente:

Introduce un Nº entero -> 84

Nº | Factores primos
-- | ---------------
84 | 2
42 | 2
21 | 3
7 | 7
1 |
Ayuda: Se deberá utilizar una función que nos diga si un número es primo o no.
12. Escribir un programa que cuente de un texto introducido por teclado:
• N.º de caracteres en blanco

• N.º de dígitos
• N.º de letras
• N.º de líneas
• N.º de otras cosas
Nota 1: Se deben crear sendas funciones para comprobar si un carácter es numérico o alfanumérico.
Nota 2: La función getchar() permite leer un carácter de teclado.
Nota 3: Para marcar el final de lectura del texto, el usuario deberá introducir un carácter que marque
fin de fichero. Este carácter es ^D en Linux y ^Z en DOS / Windows.

Ejercicios programación en C – Arrays unidimensionales / multidimensionales
Arrays
1. Escribir un programa que calcule el producto escalar de dos vectores de 3 elementos cuyos valores se
introducen por pantalla con el programa principal.
2. Escribir un programa que calcule el producto vectorial de dos vectores de 3 elementos cuyos valores
se introducen por pantalla con el programa principal.
3. Realizar un programa que lea 20 números y muestre aquel o aquellos que hayan aparecido más veces.
4. Escribir un programa que emplee un argumento de la línea de comandos para realizar una conversión
decimal a hexadecimal; es decir, el número decimal se introducirá en la línea de comandos, siguiendo
al nombre del programa.
Ej:
C:> decihex 128 111
Deci= 128 Hex= 80
Deci= 111 Hex= 6F
C:>
Nota 1: Al igual que en el ejemplo, el programa deberá ser capaz de convertir varios números en una
llamada.
Nota 2: En caso de que el programa no reciba argumentos deberá devolver un mensaje de error.
Nota 3: La función atoi() convierte de cadenas a enteros.
5. Escribir un programa que pida un array de caracteres por pantalla e invierta el orden de los caracteres
mostrándolo por pantalla. La inversión se hará sin utilizar otro array auxiliar.
6. Escribir un programa que calcule los números primos de 0 a 100 utilizando el llamado método de la
criba de Eratóstenes. Este método consiste en definir e inicializar con todos sus elementos a True un
array de 100 elementos binarios e ir “tachando” (pasando a False) en pasadas sucesivas todos los
múltiplos de los números primos (2, 3, 5, 7...) hasta obtener sólo los números primos. Es decir:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ...
En el ejemplo en gris claro se señalan los múltiplos de 2, mientras que en gris oscuro los múltiplos de
3 (que no son múltiplos de 2).
Nota: Aumentar el límite superior y comparar la velocidad de ejecución con el programa de

Sentencias Repetitivas.
7. Realizar un programa que maneje un array de enteros a través de un menú con seis opciones:
1.- Añadir un elemento al array (comprobando que el array no esté lleno)

2.- Eliminar un elemento del array (comprobando que el array no esté vacío)
3.- Listar el contenido del array
4.- Contar las apariciones de un número en el array
5.- Calcular la media y el máximo de los elementos del array
0.- Terminar
8. Escribir un programa que permita guardar las cuentas de un banco con sus respectivos saldos. Para
ello se guardará la información en un array paralelo (dos arrays unidimensionales, uno con los
números de cuenta y otro los saldos)
El programa deberá mantener las cuentas ordenadas, de menor a mayor, por número de cuenta para
facilitar la búsqueda de una cuenta.
El programa mostrará un menú con las siguientes opciones:

1.- Dar de alta una nueva cuenta (comprobando que el array no esté lleno y colocando la cuenta en la
posición correspondiente dentro del array)
2.- Eliminar una cuenta (comprobando que el array no esté vacío y reposicionando las cuentas en el
array)
3.- Mostrar una cuenta (mostrará el número de cuenta y el saldo correspondiente)
4.- Mostrar información (Número de cuentas dadas de alta y dinero total de todas ellas)
5.- Calcular el saldo medio, máximo y mínimo de las cuentas del array.
6.- Mostrar todas las cuentas (1 línea por cuenta).
0.- Terminar
9. Escribir un programa que rellene automáticamente una matriz 4x7 con la suma de sus índices (Es
decir, el elemento a11 = 1+1=2, a47 = 4+7=11). El programa mostrará la matriz resultante por pantalla.
10. Escribir un programa que pida una matriz de orden 3x3 y calcule y muestre por pantalla su matriz
transpuesta.
11. Crear un programa que permita reservar asientos de una sala de cine (8 filas x 20 columnas). La
posición de cada asiento se definirá con una letra (A-H) para la fila y un número (1-20) para la
columna. El programa deberá visualizar qué sitios están disponibles para que el cliente pueda decidir
dónde sentarse. Antes de hacer la reserva, el programa deberá comprobar que el asiento está libre, en
caso contrario devolverá un mensaje de error.
Ej. de visualización:
1...5....0 1...5....0
_______________________
A ** A
B **** *** B
C ** **** ** **** C
D *** * ** *** ** *** D
E ***** **** ** ** E
F ******** *** * ** F
G ** **** **** ** G
H ******* *** H
1...5....0 1...5....0
12. Un histograma es un gráfico que muestra la frecuencia con que aparecen en una array dado valores
dentro de subintervalos especificados de su intervalo. Por ejemplo, si un array unidimensional de
enteros tiene elementos de tipo 0..9 y contiene los siguientes valores:
6 4 4 1 9 7 5 6 4 2 3 9 5 6 4
Su histograma sería:
4 *
Frecuencia 3 * *
2 * * * *
1 * * * * * * * *
Valor 0 1 2 3 4 5 6 7 8 9
Esto indica que los valores 0 y 8 no aparecen en el array, los valores 1, 2, 3 y 7 aparecen una vez, el
valor 5 aparece dos veces, el valor 6 tres veces y el valor 4 aparece 4 veces.
Escribir un programa que, tras leer las notas de los alumnos en una asignatura, genere y visualice el
histograma de las notas redondeadas a valores enteros: 0, 1, 2,...10

Las notas leídas desde el teclado son valores de tipo real y el número de alumnos no es fijo aunque
siempre es menor de 300.
Nota: Para la realización del histograma se tendrán en cuenta las dimensiones de la pantalla no
permitiéndose más de 22 filas, por tanto si la máxima frecuencia es mayor de 22 se deberá mostrar el
histograma a escala.
13. Realizar un programa que permita calcular el NIF., conocido el DNI. de una persona.
El programa deberá leer el número del DNI. del interesado. Seguidamente deberá averiguar si es un
valor válido (debe representar un valor entre 100.000 y 99.999.999). Si la entrada es válida se deberá
calcular el NIF. y representar el número completo con los puntos de millares y millones en las
posiciones correspondientes, así como la letra del NIF al final de la cadena de caracteres separada por
un espacio en blanco.
Cálculo de la letra del NIF.:

Se obtiene el resto de la división del número del DNI. entre 23, y en función del resultado se asigna un
carácter según la siguiente tabla:
0=’T’ 7=’F’ 14=’Z’ 21=’K’

1=’R’ 8=’P’ 15=’S’ 23=’E’
2=’W’ 9=’D’ 16=’Q’
3=’A’ 10=’X’ 17=’V’
4=’G’ 11=’B’ 18=’H’
5=’M’ 12=’N’ 19=’L’
6=’Y’ 13=’J’ 20=’C’

Ejercicios de programación en C - Punteros
Punteros
1. Escribir un programa que efectúe las siguientes operaciones. -
a) Declarar las variables enteras largas value1 y value2 e inicializar value1 a 200000
b) Declarar la variable lPtr como apuntador a un objeto de tipo long.
c) Asignar la dirección de la variable value1 a la variable de apuntador lPtr.
d) Imprima el valor del objeto al que apunta lPtr.
e) Asígnele a la variable value2 el valor del objeto al que apunta lPtr.
f) Imprima el valor de value2.
g) Imprima la dirección de value1.
h) Imprima la dirección almacenada en lPtr. ¿Es igual el valor impreso que la dirección de value1?
Nota: %p muestra el valor de la variable como puntero
2. Crear un programa que calcule el valor de la intensidad que pasa a través de una resistencia dada,
cuando se le aplica un voltaje determinado.
El programa deberá estar dividido en las siguientes funciones:
• explicar_programa()
Esta función mostrará una introducción del programa por la pantalla.
• obtener_valores()
Esta función pedirá los valores para la resistencia y voltaje los cuales se pasarán por referencia al
programa principal.
• calcular()
Esta función efectuará el cálculo de la intensidad a partir de la resistencia y el voltaje aplicado.
• imprimir_respuesta()
Esta función se encargará de mostrar un mensaje con los resultados.
3. Crear una función que intercambie el contenido de dos variables. Para ello se pasarán como
parámetros las direcciones de las variables.
Para probar la función escribir un programa que pida los datos por pantalla y muestre los contenidos
después de llamar a la función.
4. Crear un programa que lea un número determinado (<100) de números reales introducidos por
teclado los almacene en un vector para mostrarlos luego en orden inverso.
Nota: Para recorrer el array se deberá usar aritmética de punteros en lugar de usar los índices del
array.
5. Escribir una función que tras pedir un día de la semana (de 1 a 7) devuelva un puntero a cadena con
el nombre del día. La función contendrá un array de apuntadores a cadena.
Para probar la función se realizará un programa que pida un día de la semana en número y escriba el
día de la semana en letra.
6. Escribir un programa que inicialice una cadena con una palabra cualquiera. El programa deberá
obtener la dirección de la primera letra de la cadena. Una vez sabida esta dirección la mostrará por
pantalla y realizará un bucle dando 3 oportunidades para que el usuario introduzca la dirección de la
tercera letra de la cadena. En caso de no introducirla bien después de los 3 intentos, deberá sacar un
mensaje indicando cuál es la dirección correcta.
Dpto. Sistemas y Automática – UPV/EHU

Ejercicios programación en C - Cadenas
Cadenas
1. Escribir un programa que pida una cadena de caracteres (de longitud máxima 80 caracteres) y
devuelva la cadena escrita al revés.
Ayuda: Para saber la longitud de la cadena se puede usar la función strlen() de la librería string.h.
2. Realizar un programa que lea una cadena de caracteres de una longitud menor de 80 y visualice los
caracteres de la siguiente forma:
primero, último, segundo, penúltimo, tercero, antepenúltimo, ...
3. Escribir una función que cambie las letras mayúsculas de una cadena a minúsculas y viceversa. El
programa principal pedirá una cadena por pantalla y se la pasará a dicha función esperando el
resultado correcto que se mostrará por pantalla.
4. Escribir un programa que pida primero un carácter por teclado y que luego pida una cadena. El
programa calculará cuántos caracteres tiene la cadena hasta que lea el carácter introducido primero.
Se deberá mostrar un mensaje en pantalla con el número de caracteres introducidos hasta llegar al
carácter primero.
5. Escribir un programa que cuente el número de letras, dígitos y signos comunes de puntuación de una
cadena introducida por teclado.
Ayuda: Para saber si un carácter es numérico comparar que su valor es mayor que ‘0’ y menor que
‘9’, para saber si es alfabético comprobar que está entre ‘a’ y ‘z’ y considerar signos de puntuación el
resto de los caracteres.
Nota: No considerar ni la ñ ni las letras acentuadas, ya que tienen códigos ASCII fuera del rango a-z
6. Realizar un programa que lea una cadena de caracteres con espacios en blanco excesivos: elimine los
espacios en blanco iniciales y finales y sólo deje uno entre cada dos palabras.
7. Crear un programa que pida una cadena de caracteres y devuelva otra sin signos de puntuación ni
números. La cadena devuelta debe tener todos los caracteres en mayúsculas.
Ayuda: Se pueden usar las siguientes funciones estándar de C:

ispunct(), islower(), gets()
En TurboC también existe la función strupr()
Código ASCII de ‘A’ 65
‘a’ 97
8. Crear un programa que pida por pantalla una cadena de 80 caracteres de longitud máxima y que
calcule el número de veces que aparece otra cadena determinada, también pedida por teclado.
Como salida el programa debe escribir un mensaje con el número de veces que aparece la palabra
dada.
Ayuda: Se pueden usar las funciones siguientes:

strstr(), gets()
9. Escribir un programa que compruebe si una cadena pedida por teclado es un palíndromo o no.
(Un palíndromo es una palabra que se lee igual al derecho que al revés.) El programa no tendrá en
cuenta si la palabra está escrita con mayúsculas o minúsculas.
Ej: radar, 11011011, Ana, Otto
10. Escribir una función que compare 2 cadenas de caracteres devolviendo –1 si son iguales y 0 si son
distintas.

11. Escribir un programa que pida dos cadenas (de longitud máxima 10 caracteres) y devuelva lo
siguiente:
• La longitud de ambas cadenas

• Un mensaje diciendo si ambas cadenas son iguales y si no los son que diga qué cadena es la
mayor y cuál la menor.
• Concatene la segunda cadena al final de la primera, dejando un espacio blanco entre ambas.
• Copia del contenido de la segunda cadena en la primera y la muestre por pantalla.
12. Escribir un programa con un menú que permita las siguientes opciones:
• Introducir una cadena de 40 caracteres de longitud máxima
• Pasar a mayúsculas una cadena leída desde teclado. Para ello, escribir un procedimiento que
transforme caracteres de letras minúsculas a mayúsculas dejando como están las letras
mayúsculas.
Nota: Para llevar a cabo esta operación tener en cuenta la representación de los caracteres en
ASCII. (‘A’ – 65, ‘a’ – 97)
• Pasar a minúsculas una cadena desde teclado. Para ello, escribir un procedimiento que
transforme caracteres de letras minúsculas a mayúsculas. Dejando como están las letras
minúsculas.
• Dada la cadena de caracteres introducida en el punto 1, obtener otra, de forma que la cadena
resultante tenga sus caracteres a una distancia d (en el código ASCII) de los caracteres de la
cadena original. Se considerará el alfabeto circular, es decir que tras la letra ‘z’ viene la letra ‘A’.
La distancia d se introducirá desde teclado.
Nota: Antes de traducir la cadena se convertirá en una cadena de letras minúsculas, tal y como
se hace en el punto 2.
• Salir del programa
Nota común: En todos los casos si se intenta efectuar alguna operación antes de introducir la cadena
se deberá mostrar un mensaje de error comunicando al usuario que la cadena está vacía.
13. Julio Cesar enviaba mensajes a sus legiones encriptando los mensajes mediante el siguiente
algoritmo:
Se escogía un número n como clave y se sumaba a cada letra en el alfabeto n posiciones. Así, si la
clave escogida fuese 5, la ‘a’ pasaría a ser la ‘f’, mientras que la ‘f’ pasaría a ser la ‘k’. Para las
últimas letras del abecedario se seguiría desde el principio. Así, con la clave de 5 la ‘y’ pasaría a ser
la ‘d’.
Se pide crear un programa que encripte una frase mediante este algoritmo.
14. Construir un programa que implemente una calculadora para números enteros:
El programa pedirá primero la operación y luego los operandos.
Las operaciones válidas serán: sumar, restar, multiplicar, dividir, salir.
Si la operación es distinta de salir se pedirán los operandos y luego se mostrará el resultado.
Si la orden es distinta de las anteriores se mostrará un error diciendo que se trata de una orden
desconocida.
Los operandos se recogerán como cadenas de caracteres y se convertirán en números enteros con la
función atoi()
Otras funciones que se pueden usar serán: gets() y strcmp().
15. Tal vez el esquema de codificación más famoso de todos es el código Morse, desarrollado por
Samuel Morse en 1832 para el sistema telegráfico. El código Morse asigna una serie de puntos y
rayas a cada letra del abecedario, a cada dígito y a algunos caracteres especiales (punto, coma, dos
puntos y punto y coma). Ver tabla adjunta.
Escribir un programa que lea una frase y la codifique en código Morse. También escriba un programa
que lea una frase en código Morse y la convierta en su equivalente en castellano. La separación entre

letras se indicará mediante un espacio, mientras que la separación entre palabras se indicará mediante
3 espacios.
Carácter Código Carácter Código

A .- T -
B -.. U ..-
C -.-. V ...-
D -.. W .--
E . X -..-
F ..-. Y -.--
G --. Z --..
H ….
I .. Dígitos
J .--- 1 .----
K -.- 2 ..---
L .-.. 3 ...--
M -- 4 ....-
N -. 5 .....
O --- 6 -....
P .--. 7 --...
Q --.- 8 ---..
R .-. 9 ----.
S … 0 -----
16. Escribir un programa que permita al usuario realizar las siguientes operaciones:
1. Mostrar la fecha y hora por pantalla

2. Sacar por pantalla el contenido de un fichero ASCII.
3. Sacar por pantalla el contenido de un directorio
4. Limpiar la pantalla
5. Salir del programa
Para ello se hará uso de los comandos del sistema operativo:

En Linux: date, cat, ls, clear
En DOS: date, time, type, dir, cls

Ejercicios programación en C – Estructuras y arrays de estructuras
Estructuras
1. Realizar un programa que permita realizar las operaciones básicas (sumar, restar, multiplicar y
dividir) números complejos.
El programa deberá utilizar una variable que represente el número complejo en su forma polar, con
sus dos componentes módulo y argumento.
2. Crear un programa que lea las siguientes variables proporcionadas desde teclado con el siguiente
formato:
Posición de los caracteres Campo
1-8 Matricula
9-13 Cilindrada
14-16 Potencia
17-27 Modelo
28-38 Marca
Ej:
BI6755CC1400 75FIESTA FORD
Y las introduzca en la correspondiente estructura. El programa deberá mostrar la estructura obtenida

para comprobar que la conversión ha sido correcta.
Nota: Construir una función que muestre la estructura por pantalla que recibirá la estructura pasada
por referencia (para no malgastar espacio en la pila)
3. Disponemos de la información correspondiente a una jaula de un Zoo en una variable de tipo registro
con los siguientes campos:
Numero de jaula Entero

Especie del animal Cadena de caracteres
Nombre del animal Cadena de caracteres
Edad Entero
Peso Real
Kilogramos de comida diaria Real
Frecuencia de limpieza de jaula Entero (veces al día)
Estado de la salud del animal Carácter (B, R, M -> Buena, Regular o Mala)
Descendencia Sí o No
Peligroso Sí o No
Por motivos de transferencia de información a otros organismos necesitamos descomponer la

información contenida en esa variable en dos variables diferentes. Una va a contener los datos de
mantenimiento de la jaula del animal:
Numero de jaula Entero

Kilogramos de comida diaria Real
Frecuencia de limpieza de jaula Entero (veces al día)
Peligroso Sí o No
Otra, los datos del animal:
Especie del animal Cadena de caracteres

Nombre del animal Cadena de caracteres
Edad Entero
Peso Real
Estado de la salud del animal Carácter (B, R, M -> Buena, Regular o Mala)
Descendencia Sí o No

Escribir un programa que lea una variable de información global y la descompongan en dos
variables, una de información de mantenimiento y otra de información del animal y visualice ambas
variables.
Nota: Dentro de los subprogramas que considere necesarios deberá haber uno, llamado
descomponer, que tome un registro y lo descomponga en dos.
4. Crear un programa que permita introducir cierta información relativa a los vuelos diarios que parten
de un aeropuerto en un array formado por registros. Cada registro contendrá la siguiente información
sobre el vuelo correspondiente:
a) Número de vuelo (No tiene por qué coincidir con el índice del array)
b) Hora de partida:
Que a su vez, tiene dos componentes:
1. Hora: 0..23
2. Minutos: 0..59
c) Origen del vuelo: Cadena de caracteres
d) Destino del vuelo: Cadena de caracteres
e) Número de pasajeros: Entero
Una vez introducidos los datos de todos los vuelos se preguntará si se desea obtener información de
algún vuelo. En caso de que el usuario responda afirmativamente se pedirá el número de vuelo. El
programa buscará el vuelo en al array y accederá a la información que contiene a partir de su número
de vuelo, mostrando por pantalla todos sus datos.
El programa se ejecutará repetitivamente hasta que el usuario indique que no desea obtener más
información de ningún vuelo.
Nota: Se deben diseñar las funciones que visualicen un vuelo, busquen un vuelo en el array,
introduzcan la información de un vuelo en el array, etc...
5. Una compañía utiliza aviones para fumigar las cosechas contra una gran variedad de plagas. Lo que
la compañía cobra a los granjeros depende de contra qué es lo que desean fumigar, y de cuantos m2
de tierra quieren que se fumiguen de acuerdo con la siguiente tabla:
Tipo1: Fumigación contra malas hierbas 3000 Pts/ m2

Tipo2: Fumigación contra langostas 6000 Pts/ m2
Tipo3: Fumigación contra gusanos 9000 Pts/ m2
Tipo4: Fumigación contra todo lo anterior 15000 Pts/ m2
Además, si el área a fumigar es mayor que 10.000 m2, el granjero goza de un descuento del 7%.
Se trata de escribir un programa que lea los datos de un conjunto de granjeros y al final calcule, para
cada uno de ellos, la factura correspondiente. De cada granjero se tendrá la siguiente información:
Nombre
Tipo de fumigación (código entre 1 y 4)
Número de m2 que se van a fumigar.
6. Escriba un programa que genere un array de 50 números enteros entre 1 y 1000 de forma aleatoria. A
continuación, partiendo de ese array genere otro array de 50 estructuras tal que cada estructuras tenga
un campo para el número y otro (cadena de caracteres) para indicar si dicho número es múltiplo
primo o no. Por ejemplo:

203 672 23 319 426 1 ........ 862 373 273 203
203 672 23 319 426 1 ........ 862 373 273 203

NO NO SI NO NO SI ........ NO SI NO NO
Finalmente muestre en pantalla la suma de todos los números del array que sean primos.
7. Escribir un programa que cree una base de datos temporal sobre el personal de agentes de policía. La
base de datos almacenará cuatro datos acerca de cada persona:
• Nombre (Array de caracteres)

• Apellido (Array de caracteres)
• Código (Entero)
• Categoría (Entero: 0: detective, 1: ayudante, 2: director)
El programa preguntará acerca de cuántos datos se añadirán a la base de datos y luego mostrará los
datos de todos los agentes introducidos.
8. Programa que implemente una agenda.
Se guardarán los siguientes datos por persona:
• Nombre: Máximo 20 caracteres.

• Apellidos: Máximo 40 caracteres.
• Sobrenombre: Máximo 10 caracteres.
• Teléfono: Máximo 10 caracteres.
Se creará un menú con las siguientes opciones:
1. Alta de una nueva persona a la agenda con los correspondientes datos.

2. Eliminar a una persona de la agenda.
3. Búsqueda de un nombre en particular (La búsqueda se hará por sobrenombre)
4. Listado de todas las personas empezando por la primera introducida (Para pasar a la siguiente se
deberá pulsar intro).
5. Guardar agenda en disco.
0. Salir
9. Se deberá escribir un programa que permita introducir y consultar la tabla periódica de los elementos
químicos. Para ello, se construirá un menú con las siguientes opciones:
1. Introducir elementos de la tabla periódica

2. Listar todos los elementos de tabla periódica
3. Mostrar elemento de la tabla periódica por número atómico
4. Mostrar elemento de la tabla periódica por símbolo
5. Salir
La opción 1 preguntará cuántos elementos de la tabla periódica se quieren introducir e irá

preguntando sucesivamente por ellos.
Evidentemente, no es necesario rellenar el array con todos los elementos de la tabla periódica.
La opción 2 listará la información acerca de todos los elementos químicos introducidos
ordenados por número atómico.
La opción 3 pedirá el número atómico del elemento que se quiere consultar y mostrará por
pantalla la información correspondiente a dicho elemento.

La opción 4 pedirá el símbolo del elemento que se quiere consultar y mostrará por pantalla la
información correspondiente a dicho elemento.
Se guardará la siguiente información sobre cada elemento.
1. Símbolo del elemento

2. Nombre completo
3. Peso Atómico
El número atómico vendrá indicado por la posición en el array de elementos que representa la
tabla periódica, y por tanto no será necesario almacenar esta información en el registro
correspondiente.
Nota: Se puede mejorar el programa añadiendo una opción que permita guardar los datos en un
fichero de disco.

Ejercicios programación en C - Ficheros
Ficheros
1. Crear un programa que abra un fichero y escriba en él dos números enteros y otro programa que lea
el segundo número escrito del fichero.
Ayuda: Úsense las funciones fprintf y fscanf.
2. Leer completamente un fichero de texto, carácter a carácter (o en cantidades mayores, para que sea más
rápido). El programa debe contar las vocales, los caracteres alfabéticos y los dígitos que hay en el
fichero.
3. Crear un programa que abra un fichero y escriba en él dos cadenas, cada una acabada con el carácter
de nueva línea y otro programa que lea la segunda cadena escrita en el mismo fichero.
Comprobar que el fichero existe y visualizar su contenido con un editor de textos (p.e. el Block de
Notas de Windows)
Nota: Escribir una cadena con espacios intercalados.

Ayuda: Úsense las funciones fputs y fgets. Consultar la ayuda.
4. Escribir un programa que tome caracteres de teclado y, de uno en uno, los escriba en un fichero cuyo
nombre es previamente pedido por pantalla.
5. Escribir un programa que saque por pantalla el contenido de un fichero cuyo nombre es pedido por
pantalla.
Nota: El nombre del fichero debe proporcionarse mediante la línea de argumentos al llamar al
fichero. Es decir:
C:> MostrFic fichero.txt
6. Escribir un programa que comprueba que un fichero de código contiene el mismo número de “{“ que
de “}” en su código. En caso de que no sea así el programa mostrará un mensaje indicando que el
número de “{“ es distinto que el número de “}”.
7. Escribir un programa que use dos ficheros: uno de lectura y otro de escritura. El programa leerá los
caracteres de un fichero, y tras una operación de cambio de mayúsculas a minúsculas y viceversa,
escogida por el usuario, los escribirá en un segundo fichero.
8. Escribir el código necesario en el programa de la agenda de la lección de estructuras (Ejercicio 8)

para que la información de la agenda pueda leerse desde disco al arrancar el programa y actualizarse
su contenido en disco cuando el usuario lo requiere con la opción de Guardar.
9. Escribir un programa que permita visualizar el contenido de un fichero pasado desde la línea de
comando en formatos hexadecimal y carácter, siguiendo el esquema del ejemplo:
C:> Ver Fichero.txt

48 6F 6C 61 2C 20 73 6F-79 20 75 6E 61 20 63 61 Hola, soy una ca
64 65 6E 61 0D 0A 59 20-79 6F 20 6F 74 72 61 0D dena..Y yo otra.
0A EB 11 80 3E AF D2 00-74 03 E8 B2 E8 E8 FC E6 ....>...t.......
Ayuda: Para averiguar si un carácter se puede imprimir existe la función isprint().
10. Escribir un programa que pida el nombre de un fichero y lo borre de disco.
Ayuda: Usar la función remove().
11. Crear una base de datos almacenada en un fichero para personal universitario. Cada elemento de la
base de datos constará de 3 campos: Nombre, apellido y edad.

Adicionalmente, será necesario crear otro programa que lea los registros de la base de datos y los
muestre secuencialmente por pantalla.
12. Escribir un programa que haga una conversión de un tipo de formato de fichero a otro. El formato de
partida será el siguiente:
Posición de los caracteres Campo

1-8 Matricula
9-13 Cilindrada
14-16 Potencia
17-27 Modelo
28-38 Marca
Ej:
BI6755CC1400 75FIESTA FORD
y el formato de destino serán las correspondientes estructuras, es decir:
Matrícula 8 caracteres
Cilindrada entero
Potencia entero
Modelo 10 caracteres
Marca 10 caracteres
Nota: Los datos de partida pueden introducirse con el programa 2.
13. Una entidad bancaria posee en un fichero la siguiente información para un conjunto de personas:
• Nombre.
• Número de cuenta.
• Crédito solicitado.
El programa funcionará basándose en un menú con las siguientes operaciones:
1.- Añadir un crédito al archivo

2.- Visualizar en pantalla la información correspondiente al crédito mayor
3.- Copiará en otro fichero el conjunto de personas que hayan solicitado un crédito superior a
cierta cantidad establecida por el banco (la cual deberá ser introducida por teclado).
4.- Visualizar todo el contenido de un archivo
14. Se pide crear un programa que a partir de la fórmula de un compuesto químico, supuestamente puro,
y su peso en gramos presente un informe con la cantidad en gramos de cada elemento del compuesto.
Evidentemente, el programa deberá consultar la información contenida en la tabla periódica. Esta

información deberá estar disponible en un fichero que el programa leerá al empezar a ejecutarse. La
información de la tabla periódica que será relevante, por ejemplo para el elemento químico hierro
será la siguiente:
• Número atómico 26
• Símbolo del elemento químico Fe
• Nombre completo del elemento Hierro
• Peso atómico 55,87
Nota 1: Para todas las ejecuciones del programa los datos de la tabla periódica deberán estar
disponibles por el programa. Se deja a elección de los alumnos el método de creación del fichero con
los datos de la tabla periódica.
Nota 2: Se recuerda que el número atómico indica la posición de un elemento en la tabla periódica.
Habrá que pensar cómo se organiza esta información para que el programa pueda funcionar de la
forma más sencilla posible.

El programa pedido presentará el siguiente menú:
1. Listar tabla periódica

2. Mostrar elemento de la tabla periódica
3. Mostrar composición del compuesto
0. Salir
Donde:
Opción 1 mostrará un listado con todos los elementos de la tabla periódica. Dado que la tabla
periódica tiene 118 elementos y sólo hay 40 líneas por pantalla, el programa deberá mostrar los
elementos en grupos de 40 líneas para poder visualizar la información de todos los elementos.
Ejemplo de la primera pantalla:
N. Atómico Símbolo Nombre Peso Atómico

1 H Hidrógeno 1.001
...
38 Sr Estroncio 87.62
Pulsa una tecla para continuar
Opción 2 mostrará toda la información de un elemento químico. Para ello permitirá buscar un
elemento bien por número atómico o por símbolo. Así, previamente se preguntará si se busca el
elemento por número atómico o por símbolo:
INFORMACIÓN DEL ELEMENTO QUÍMICO
Número atómico: 26
Símbolo: Fe
Nombre completo: Hierro
Peso atómico: 55.85
Opción 3 permitirá obtener la composición del compuesto químico a partir de la fórmula y del peso
del compuesto.
Se deberá comprobar que la fórmula escrita es válida, esto implicará comprobar que TODOS los
elementos escritos existen en la tabla periódica y que se ha seguido el formato:
Elemento[Número de átomos]Elemento[Número de átomos]...
Tal y como sucede en la notación usual el número de átomos es opcional, sobreentendiéndose en

caso de que no haya ningún número especificado que sólo hay un átomo del elemento en el
compuesto.
La fórmula podrá tener un máximo de 10 elementos y un mínimo de 1.
Nota 3: Se recuerda que todos los átomos empiezan por letra mayúscula y que algunos átomos tienen
una letra minúscula mientras que otros no. No hay átomos de tres letras.
Una vez que se haya comprobado que la fórmula es correcta y se hayan identificado tanto los
elementos componentes como el número de átomos de cada tipo en la molécula el programa se
presentará el siguiente informe:
COMPOSICIÓN
Compuesto químico SiO2

Peso (en gramos): 1000
Gramos de Silicio: 467,5
Gramos de Oxígeno 532,5

Manual de Hardware - Historia de Los Sistemas Informaticos PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de Hardware - Historia de Los Sistemas Informaticos PDF

Cargado por

Copyright:

Formatos disponibles

SISTEMAS INFORMÁTICOS

Profesores Departamento Curso Académico

Tema 2. Estructura general de un sistema de computación.

Tema 3. Codificación de la información.

Tema 4. Fundamentos de sistemas operativos.

Tema 5. Lenguajes de programación.

Tema 6. Programación estructurada.

Tema 7. Elementos base de programación.

Tema 10. Instrucciones.

Tema 11. Subprogramas

Tema 12. Funciones

Tema 13. Tipos estructurados

Tema 14. Archivos

Linux - Edición Especial

Fundamentos de Programación, Algoritmos y Estructura de Datos

Curso de Programación C/C++

¾ Examen Final – Obligatorio (80% de la nota final). Nota mínima de aprobado 5.

¾ Laboratorio – Obligatorio (20% de la nota final). Nota mínima de aprobado 5. La

Computadora u Ordenador: Es una máquina electrónica capaz de aceptar unos

Calculadora: (acepción actual) Es una máquina capaz de efectuar operaciones

Hardware vs. Software

Software: Programas que dirigen el funcionamiento de un ordenador

Firmware: Ente intermedio entre el hardware y el software

Ordenador de Propósito General: Puede ejecutar un amplio rango de

Evolución de los Sistemas de Calculo – Ábaco

Origen Nombre Características

Evolución – Calculadoras Mecánicas 2

La Máquina Diferencial: (1821) capaz de

La Máquina Analítica: (1833) sistema

Evolución – Las Primeras Computadoras 1

Mark I Computer (ASCC) Automatic

Evolución – Las Primeras Computadoras 2

ENIAC (Electronic Numerical Integrator

Babbage vs. Von Newman

Algunas de las realizaciones son: UNIVAC | EDSAC | EDVAC | ORDAC | ILLIAC |

Algunas de las realizaciones son: IBM System/360 | GE 600 | PDP-11

Chasis en disposición de Torre

Estructura Interna de un Microcomputador

Ö Elemento principal al que

Esquema del formato Baby AT.

La Placa Base (II)

Componentes de la Placa Base

Ö Niveles de c.c. Ö Convierte la energía alterna

La Fuente de Alimentación - Conectores

Conectores ATX en Placa Base

Ö Determina el rendimiento y características de la placa.

Ö Un ordenador utiliza la memoria RAM

Clasificación de la Memoria por Tipos

DINAMICA ESTATICA PROM Y EPROM

DDR-RAM RDRAM (RAMBUS)

Ö Memoria ROM, EPROM,

BIOS – Pantalla de Configuración

Ö Es el chip más importante

Ö Al conectar una tarjeta a un bus de expansión, ésta

Ö PCI Ö SCSI Ö AGP Ö ISA

Buses de Expansión (II)

Vesa Local Bus

Ö Dispositivos que se conectan a la placa base por

El Disco Duro (I)

Instalación de Varios Disp. de Almacenamiento

Ö Las controladoras EIDE,

Ö Una controladora SCSI(las

Tarjetas de Vídeo y Sonido

Ö Memoria ROM, EPROM,