CAPITULOSMOD

CAPITULO 1
INTRODUCCIÓN A LA COMPUTACIÓN
Hoy en día todas las personas que se inicien en el ámbito de la programación, necesitan
conocer los conceptos básicos de la computación, para poder comprender el
procesamiento de información mediante computadoras y utilizarlas con bases sólidas en
el desarrollo de los programas y su uso en general.
Computadora. Es un dispositivo electrónico capaz de ejecutar cálculos y tomar
decisiones lógicas a velocidades a miles de millones de veces más rápidas de lo que
pueden hacerlo los seres humanos.
El mundo de la alta tecnología nunca hubiera existido de no ser por el desarrollo de la
computadora. Toda la sociedad utiliza estas máquinas, en distintos tipos y tamaños, para
el almacenamiento y manipulación de datos. Los equipos informáticos han abierto una
nueva era en la fabricación gracias a las técnicas de automatización, y han permitido
mejorar los sistemas modernos de comunicación. Son herramientas esenciales
prácticamente en todos los campos de investigación y en tecnología aplicada.
TIPOS DE COMPUTADORAS
En la actualidad se utilizan dos tipos principales de computadoras: analógicas y digitales.
Sin embargo, el término computadora suele utilizarse para referirse exclusivamente al tipo
digital.
Las computadoras analógicas aprovechan la similitud matemática entre las interrelaciones
físicas de determinados problemas y emplean circuitos electrónicos o hidráulicos para
simular el problema físico. Las computadoras digitales resuelven los problemas realizando
cálculos y tratando cada número dígito por dígito.
Las instalaciones que contienen elementos de computadoras digitales y analógicas se
denominan computadoras híbridas. Por lo general se utilizan para problemas en los que
hay que calcular grandes cantidades de ecuaciones complejas, conocidas como
integrales de tiempo. En una computadora digital también pueden introducirse datos en
forma analógica mediante un convertidor analógico digital, y viceversa (convertidor digital
a analógico).
COMPUTADORAS ANALÓGICAS
La computadora analógica es un dispositivo electrónico o hidráulico diseñado para
manipular la entrada de datos en términos de, por ejemplo, niveles de tensión o presiones
hidráulicas, en lugar de hacerlo como datos numéricos. El dispositivo de cálculo analógico
más sencillo es la regla de cálculo, que utiliza longitudes de escalas especialmente
calibradas para facilitar la multiplicación, la división y otras funciones. En la típica
computadora analógica electrónica, las entradas se convierten en tensiones que pueden
sumarse o multiplicarse empleando elementos de circuito de diseño especial. Las
respuestas se generan continuamente para su visualización o para su conversión en otra
forma deseada.
COMPUTADORAS DIGITALES
Todo lo que hace una computadora digital se basa en una operación: la capacidad de
determinar si un conmutador, o ‘puerta’, está abierto o cerrado. Es decir, la computadora
puede reconocer sólo dos estados en cualquiera de sus circuitos microscópicos: abierto o
cerrado, alta o baja tensión o, en el caso de números, 0 o 1. Sin embargo, es la velocidad
con la cual el ordenador realiza este acto tan sencillo lo que lo convierte en una maravilla
de la tecnología moderna. Las velocidades del ordenador se miden en megahercios, o
millones de ciclos por segundo. Una computadora con una velocidad de reloj de 100 MHz,
APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 1
velocidad bastante representativa de una microcomputadora, es capaz de ejecutar 100
millones de operaciones discretas por segundo. Las microcomputadoras de las
compañías pueden ejecutar entre 150 y 200 millones de operaciones por segundo,
mientras que las supercomputadoras utilizadas en aplicaciones de investigación y de
defensa alcanzan velocidades de miles de millones de ciclos por segundo.
La velocidad y la potencia de cálculo de las computadoras digitales se incrementan aún
más por la cantidad de datos manipulados durante cada ciclo. Si un ordenador verifica
sólo un conmutador cada vez, dicho conmutador puede representar solamente dos
comandos o números. Así, ON simbolizaría una operación o un número, mientras que
OFF simbolizará otra u otro. Sin embargo, al verificar grupos de conmutadores enlazados
como una sola unidad, la computadora aumenta el número de operaciones que puede
reconocer en cada ciclo.
Por ejemplo, una computadora que verifica dos conmutadores cada vez, puede
representar cuatro números (del 0 al 3), o bien ejecutar en cada ciclo una de las cuatro
operaciones, una para cada uno de los siguientes modelos de conmutador: OFF-OFF (0),
OFF-ON (1), ON-OFF (2) u ON-ON (3). En general, las computadoras de la década de
1970 eran capaces de verificar 8 conmutadores simultáneamente; es decir, podían
verificar ocho dígitos binarios, de ahí el término bit de datos en cada ciclo. Un grupo de
ocho bits se denomina byte y cada uno contiene 256 configuraciones posibles de ON y
OFF (o 1 y 0). Cada configuración equivale a una instrucción, a una parte de una
instrucción o a un determinado tipo de dato; estos últimos pueden ser un número, un
carácter o un símbolo gráfico. Por ejemplo, la configuración 11010010 puede representar
datos binarios, en este caso el número decimal 210, o bien estar indicando al ordenador
que compare los datos almacenados en estos conmutadores con los datos almacenados
en determinada ubicación del chip de memoria.
El desarrollo de procesadores capaces de manejar simultáneamente 16, 32 y 64 bits de
datos ha permitido incrementar la velocidad de las computadoras. La colección completa
de configuraciones reconocibles, es decir, la lista total de operaciones que una
computadora es capaz de procesar, se denomina conjunto, o repertorio, de instrucciones.
Ambos factores, el número de bits simultáneos y el tamaño de los conjuntos de
instrucciones, continúa incrementándose a medida que avanza el desarrollo de las
computadoras digitales modernas.
CARACTERÍSTICAS DE LAS COMPUTADORAS

Las computadoras realizan un paso a la vez. Pueden sumar, restar, dividir, multiplicar,
comparar letras y números.
Rapidez. Las computadoras son muy rápidas, la rapidez varían desde: milisegundos una
milésima de segundo microsegundo una millonésima de segundo nanosegundo una
billonésima de segundo psicosegundo una trillonésima de segundo.
Exactitud/Precisión. Las computadoras realizan exactamente lo que se les indica. Se
estima que un humano tendría un error en cada 500 o 1,000 operaciones con una
calculadora. Los circuitos de la computadora pueden ejecutar millones de operaciones
cada segundo y pueden corregir sin errores por horas y días sin interrupción.
Eficiencia. Las computadoras pueden trabajar sin parar, no se aburren y no tienen miedo
ni incomodidades.
Capacidad. Pueden manejar cantidades enormes de información.
Confiabilidad (Autocomprobación). Tienen la capacidad de verificar la exactitud de sus
operaciones internas:
Datos Programa Datos. Introducidos + Introducidos = Exactos

Correctamente Procesamiento de Salida. Los errores de la computadora generalmente se
deben a la entrada de datos incorrectos o a programas no confiables, ambos usualmente
causados por los humanos.
Manipulación de Símbolos. Es posible si un código numérico de identificación es asignado
al símbolo a ser almacenado y procesado.
Ejecución de Ciertas Operaciones Lógicas. La computadora es capaz de ejecutar una
sencilla comparación (entre dos datos) y según sea el resultado seguir una determinada
trayectoria. Esta capacidad de comparar es una propiedad importante de la computadora
porque las preguntas más complejas pueden ser contestadas usando combinaciones de
decisiones de comparación (la lógica de la aplicación debe ser comprensibles, la meta
debe estar claramente definida). Son cada vez más pequeñas, más útiles y menos
costosas.
HISTORIA DE LA COMPUTACIÓN
La primera máquina de calcular mecánica, un precursor de la computadora digital, fue
inventada en 1642 por el matemático francés Blaise Pascal. Aquel dispositivo utilizaba
una serie de ruedas de diez dientes en las que cada uno de los dientes representaba un
dígito del 0 al 9. Las ruedas estaban conectadas de tal manera que podían sumarse
números haciéndolas avanzar el número de dientes correcto. En 1670 el filósofo y
matemático alemán Gottfried Wilhelm Leibniz perfeccionó esta máquina e inventó una que
también podía multiplicar.
El inventor francés Joseph Marie Jacquard, al diseñar un telar automático, utilizó delgadas
placas de madera perforadas para controlar el tejido utilizado en los diseños complejos.
Durante la década de 1880 el estadístico estadounidense Herman Hollerith concibió la
idea de utilizar tarjetas perforadas, similares a las placas de Jacquard, para procesar
datos. Hollerith consiguió compilar la información estadística destinada al censo de
población de 1890 de Estados Unidos mediante la utilización de un sistema que hacía
pasar tarjetas perforadas sobre contactos eléctricos.
LA MÁQUINA ANALÍTICA
También en el siglo XIX el matemático e inventor británico Charles Babbage elaboró los
principios de la computadora digital moderna. Inventó una serie de máquinas, como la
máquina diferencial, diseñadas para solucionar problemas matemáticos complejos.
Muchos historiadores consideran a Babbage y a su socia, la matemática británica Augusta
Ada Byron (1815-1852), hija del poeta inglés Lord Byron, como a los verdaderos
inventores de la computadora digital moderna. La tecnología de aquella época no era
capaz de trasladar a la práctica sus acertados conceptos; pero una de sus invenciones, la
máquina analítica, ya tenía muchas de las características de una computadora moderna.
Incluía una corriente, o flujo de entrada en forma de paquete de tarjetas perforadas, una
memoria para guardar los datos, un procesador para las operaciones matemáticas y una
impresora para hacer permanente el registro.
Primeras computadoras. Las computadoras analógicas comenzaron a construirse a
principios del siglo XX. Los primeros modelos realizaban los cálculos mediante ejes y
engranajes giratorios. Con estas máquinas se evaluaban las aproximaciones numéricas
de ecuaciones demasiado difíciles como para poder ser resueltas mediante otros
métodos. Durante las dos guerras mundiales se utilizaron sistemas informáticos
analógicos, primero mecánicos y más tarde eléctricos, para predecir la trayectoria de los
torpedos en los submarinos y para el manejo a distancia de las bombas en la aviación.

COMPUTADORAS ELECTRÓNICAS
Durante la II Guerra Mundial (1939-1945), un equipo de científicos y matemáticos que
trabajaban en Bletchley Park, al norte de Londres, crearon lo que se consideró la primera
computadora digital totalmente electrónica: el Colossus. Hacia diciembre de 1943 el
Colossus, que incorporaba 1.500 válvulas o tubos de vacío, era ya operativo. Fue utilizado
por el equipo dirigido por Alan Turing para descodificar los mensajes de radio cifrados de
los alemanes. En 1939 y con independencia de este proyecto, John Atanasoff y Clifford
Berry ya habían construido un prototipo de máquina electrónica en el Iowa State College
(EEUU). Este prototipo y las investigaciones posteriores se realizaron en el anonimato, y
más tarde quedaron eclipsadas por el desarrollo del Calculador e integrador numérico
electrónico (en inglés ENIAC, Electronic Numerical Integrator and Computer) en 1946. El
ENIAC, que según se demostró se basaba en gran medida en el ordenador Atanasoff-
Berry (en inglés ABC, Atanasoff-Berry Computer), obtuvo una patente que caducó en
1973, varias décadas más tarde.
LA Computadora ENIAC contenía 18.000 válvulas de vacío y tenía una velocidad de
varios cientos de multiplicaciones por minuto, pero su programa estaba conectado al
procesador y debía ser modificado manualmente. Se construyó un sucesor del ENIAC con
un almacenamiento de programa que estaba basado en los conceptos del matemático
húngaro-estadounidense John von Neumann. Las instrucciones se almacenaban dentro
de una llamada memoria, lo que liberaba a la computadora de las limitaciones de
velocidad del lector de cinta de papel durante la ejecución y permitía resolver problemas
sin necesidad de volver a conectarse al ordenador.
A finales de la década de 1950 el uso del transistor en las computadoras marcó el
advenimiento de elementos lógicos más pequeños, rápidos y versátiles de lo que
permitían las máquinas con válvulas. Como los transistores utilizan mucha menos energía
y tienen una vida útil más prolongada, a su desarrollo se debió el nacimiento de máquinas
más perfeccionadas, que fueron llamadas computadoras de segunda generación. Los
componentes se hicieron más pequeños, así como los espacios entre ellos, por lo que la
fabricación del sistema resultaba más barata.
CIRCUITOS INTEGRADOS
A finales de la década de 1960 apareció el circuito integrado (CI), que posibilitó la
fabricación de varios transistores en un único sustrato de silicio en el que los cables de
interconexión iban soldados. El circuito integrado permitió una posterior reducción del
precio, el tamaño y los porcentajes de error. El microprocesador se convirtió en una
realidad a mediados de la década de 1970, con la introducción del circuito de integración
a gran escala (LSI, acrónimo de Large Scale Integrated) y, más tarde, con el circuito de
integración a mayor escala (VLSI, acrónimo de Very Large Scale Integrated), con varios
miles de transistores interconectados soldados sobre un único sustrato de silicio.
Todas las computadoras digitales modernas son similares conceptualmente con
independencia de su tamaño. Sin embargo, pueden dividirse en varias categorías según
su precio y rendimiento: La computadora personal es una máquina de coste relativamente
bajo y por lo general de tamaño adecuado para un escritorio (algunas de ellas,
denominadas portátiles, o laptops, son lo bastante pequeñas como para caber en un
maletín); la estación de trabajo, un microordenador con gráficos mejorados y capacidades
de comunicaciones que lo hacen especialmente útil para el trabajo de oficina; la
minicomputadora, una computadora de mayor tamaño que por lo general es demasiado
cara para el uso personal y que es apta para compañías, universidades o laboratorios; y
el mainframe, una gran máquina de alto precio capaz de servir a las necesidades de
grandes empresas, departamentos gubernamentales, instituciones de investigación

científica y similares (las máquinas más grandes y más rápidas dentro de esta categoría
se denominan supercomputadoras).
En realidad, una computadora digital no es una única máquina, en el sentido en el que la
mayoría de la gente considera a las computadoras.
Hardware. Es un sistema compuesto de cinco elementos diferenciados: CPU. (Unidad
Central de Proceso); dispositivos de entrada; dispositivos de almacenamiento de
memoria; dispositivos de salida y una red de comunicaciones, denominada bus, que
enlaza todos los elementos del sistema y conecta a éste con el mundo exterior.
CPU (unidad central de proceso). La CPU puede ser un único chip o una serie de chips
que realizan cálculos aritméticos y lógicos y que temporizan y controlan las operaciones
de los demás elementos del sistema. Las técnicas de miniaturización y de integración han
posibilitado el desarrollo de un chip de CPU denominado microprocesador, que incorpora
un sistema de circuitos y memoria adicionales. El resultado son unos ordenadores más
pequeños y la reducción del sistema de circuitos de soporte. Los microprocesadores se
utilizan en la mayoría de los ordenadores personales de la actualidad.
La mayoría de los chips de CPU y de los microprocesadores están compuestos de cuatro
secciones funcionales: una unidad aritmética/lógica; unos registros; una sección de
control y un bus interno.
La unidad aritmética/lógica. Proporciona al chip su capacidad de cálculo y permite la
realización de operaciones aritméticas y lógicas. Los registros son áreas de
almacenamiento temporal que contienen datos, realizan un seguimiento de las
instrucciones y conservan la ubicación y los resultados de dichas operaciones.
La sección de control. Tiene tres tareas principales: temporiza y regula las operaciones de
la totalidad del sistema informático; su descodificador de instrucciones lee las
configuraciones de datos en un registro designado y las convierte en una actividad, como
podría ser sumar o comparar, y su unidad interruptora indica en qué orden utilizará la CPU
las operaciones individuales y regula la cantidad de tiempo de CPU que podrá consumir
cada operación..
El último segmento de un chip de CPU o microprocesador es su bus interno, una red de
líneas de comunicación que conecta los elementos internos del procesador y que también
lleva hacia los conectores externos que enlazan al procesador con los demás elementos
del sistema informático. Los tres tipos de bus de la CPU son: el bus de control que
consiste en una línea que detecta las señales de entrada y de otra línea que genera
señales de control desde el interior de la CPU; el bus de dirección, una línea
unidireccional que sale desde el procesador y que gestiona la ubicación de los datos en
las direcciones de la memoria; y el bus de datos, una línea de transmisión bidireccional
que lee los datos de la memoria y escribe nuevos datos en ésta.
DISPOSITIVOS DE ENTRADA
Estos dispositivos permiten al usuario del ordenador introducir datos, comandos y
programas en la CPU. El dispositivo de entrada más común es un teclado similar al de las
máquinas de escribir. La información introducida con el mismo, es transformada por el
ordenador en modelos reconocibles. Otros dispositivos de entrada son los lápices ópticos,
que transmiten información gráfica desde tabletas electrónicas hasta el ordenador;
joysticks y el ratón o mouse, que convierte el movimiento físico en movimiento dentro de
una pantalla de ordenador; los escáners luminosos, que leen palabras o símbolos de una
página impresa y los traducen a configuraciones electrónicas que el ordenador puede
manipular y almacenar; y los módulos de reconocimiento de voz, que convierten la
palabra hablada en señales digitales comprensibles para el ordenador. También es posible
utilizar los dispositivos de almacenamiento para introducir datos en la unidad de proceso.

Dispositivos de almacenamiento. Los sistemas informáticos pueden almacenar los datos
tanto interna (en la memoria) como externamente (en los dispositivos de
almacenamiento). Internamente, las instrucciones o datos pueden almacenarse por un
tiempo en los chips de silicio de la RAM (memoria de acceso aleatorio) montados
directamente en la placa de circuitos principal de la computadora, o bien en chips
montados en tarjetas periféricas conectadas a la placa de circuitos principal del
ordenador. Estos chips de RAM constan de conmutadores sensibles a los cambios de la
corriente eléctrica. Los chips de RAM estática conservan sus bits de datos mientras la
corriente siga fluyendo a través del circuito, mientras que los chips de RAM dinámica
(DRAM, acrónimo de Dynamic Random Access Memory) necesitan la aplicación de
tensiones altas o bajas a intervalos regulares aproximadamente cada dos milisegundos
para no perder su información.
Otro tipo de memoria interna son los chips de silicio en los que ya están instalados todos
los conmutadores. Las configuraciones en este tipo de chips de ROM (memoria de sólo
lectura) forman los comandos, los datos o los programas que el ordenador necesita para
funcionar correctamente. Los chips de RAM son como pedazos de papel en los que se
puede escribir, borrar y volver a utilizar; los chips de ROM son como un libro, con las
palabras ya escritas en cada página. Tanto los primeros como los segundos están
enlazados a la CPU a través de circuitos.
Los dispositivos de almacenamiento externos, que pueden residir físicamente dentro de la
unidad de proceso principal del ordenador, están fuera de la placa de circuitos principal.
Estos dispositivos almacenan los datos en forma de cargas sobre un medio
magnéticamente sensible, por ejemplo una cinta de sonido o, lo que es más común, sobre
un disco revestido de una fina capa de partículas metálicas. Los dispositivos de
almacenamiento externo más frecuentes son los disquetes y los discos duros, aunque la
mayoría de los grandes sistemas informáticos utiliza bancos de unidades de
almacenamiento en cinta magnética. Los discos flexibles pueden contener, según sea el
sistema, desde varios centenares de miles de bytes hasta bastante más de un millón de
bytes de datos. Los discos duros no pueden extraerse de los receptáculos de la unidad de
disco, que contienen los dispositivos electrónicos para leer y escribir datos sobre la
superficie magnética de los discos y pueden almacenar desde varios millones de bytes
hasta algunos centenares de millones. La tecnología de CD-ROM, que emplea las
mismas técnicas láser utilizadas para crear los discos compactos (CD) de audio, permiten
capacidades de almacenamiento del orden de varios cientos de megabytes (millones de
bytes) de datos.
DISPOSITIVOS DE SALIDA
Estos dispositivos permiten al usuario ver los resultados de los cálculos o de las
manipulaciones de datos de la computadora. El dispositivo de salida más común es la
unidad de visualización (VDU, acrónimo de Video Display Unit), que consiste en un
monitor que presenta los caracteres y gráficos en una pantalla similar a la del televisor.
Por lo general, las VDU tienen un tubo de rayos catódicos como el de cualquier televisor,
aunque los ordenadores pequeños y portátiles utilizan hoy pantallas de cristal líquido
(LCD, acrónimo de Liquid Crystal Displays) o electroluminiscentes. Otros dispositivos de
salida más comunes son las impresoras y los módem. Modem. Un módem enlaza dos
ordenadores transformando las señales digitales en analógicas para que los datos puedan
transmitirse a través de las telecomunicaciones.
Sistemas operativos. Los sistemas operativos internos fueron desarrollados sobre todo
para coordinar y trasladar estos flujos de datos que procedían de fuentes distintas, como
las unidades de disco o los coprocesadores (chips de procesamiento que ejecutan
operaciones simultáneamente con la unidad central, aunque son diferentes). Un sistema

operativo es un programa de control principal, almacenado de forma permanente en la
memoria, que interpreta los comandos del usuario que solicita diversos tipos de servicios,
como visualización, impresión o copia de un archivo de datos; presenta una lista de todos
los archivos existentes en un directorio o ejecuta un determinado programa.
Programación. Un programa es una secuencia de instrucciones que indican al hardware
de un ordenador qué operaciones debe realizar con los datos. Los programas pueden
estar incorporados al propio hardware, o bien pueden existir de manera independiente en
forma de software. En algunas computadoras especializadas las instrucciones operativas
están incorporadas en el sistema de circuitos; entre los ejemplos más comunes pueden
citarse los microordenadores de las calculadoras, relojes de pulsera, motores de coches y
hornos microondas. Por otro lado, un ordenador universal, o de uso general, contiene
algunos programas incorporados (en la ROM) o instrucciones (en el chip del procesador),
pero depende de programas externos para ejecutar tareas útiles. Una vez programado,
podrá hacer tanto o tan poco como le permita el software que lo controla en determinado
momento.
Software. El software de uso más generalizado incluye una amplia variedad de programas
de aplicaciones, es decir, instrucciones al ordenador acerca de cómo realizar diversas
tareas.
Las instrucciones deben darse en un lenguaje de programación, es decir, en una
determinada configuración de información digital binaria. En las primeras computadoras,
la programación era una tarea difícil y laboriosa ya que los conmutadores ON-OFF de las
válvulas de vacío debían configurarse a mano. Programar tareas tan sencillas como
ordenar una lista de nombres requería varios días de trabajo de equipos de
programadores. Desde entonces se han inventado varios lenguajes informáticos, algunos
orientados hacia funciones específicas y otros centrados en la facilidad de uso.
LENGUAJES DE PROGRAMACIÓN
Lenguaje máquina (bajo nivel). El lenguaje propio del ordenador, basado en el sistema
binario, o código máquina, resulta difícil de utilizar para las personas. El programador
debe introducir todos y cada uno de los comandos y datos en forma binaria, y una
operación sencilla como comparar el contenido de un registro con los datos situados en
una ubicación del chip de memoria puede tener el siguiente formato: 11001010 00010111
11110101 00101011. La programación en lenguaje máquina es una tarea tan tediosa y
consume tanto tiempo que muy raras veces lo que se ahorra en la ejecución del programa
justifica los días o semanas que se han necesitado para escribir el mismo.
Lenguaje ensamblador. Uno de los métodos inventados por los programadores para
reducir y simplificar el proceso es la denominada programación con lenguaje
ensamblador. Al asignar un código mnemotécnico (por lo general de tres letras) a cada
comando en lenguaje máquina, es posible escribir y depurar o eliminar los errores lógicos
y de datos en los programas escritos en lenguaje ensamblador, empleando para ello sólo
una fracción del tiempo necesario para programar en lenguaje máquina.
En el lenguaje ensamblador, cada comando mnemotécnico y sus operadores simbólicos
equivalen a una instrucción de máquina. Un programa ensamblador traduce el código
fuente, una lista de códigos de operación mnemotécnicos y de operadores simbólicos, a
código objeto (es decir, a lenguaje máquina) y, a continuación, ejecuta el programa.
Sin embargo, el lenguaje ensamblador puede utilizarse con un solo tipo de chip de CPU o
microprocesador. Los programadores, que dedicaron tanto tiempo y esfuerzo al
aprendizaje de la programación de un ordenador, se veían obligados a aprender un nuevo
estilo de programación cada vez que trabajaban con otra máquina. Lo que se necesitaba
era un método abreviado en el que un enunciado simbólico pudiera representar una
secuencia de numerosas instrucciones en lenguaje máquina, y un método que permitiera

que el mismo programa pudiera ejecutarse en varios tipos de máquinas. Estas
necesidades llevaron al desarrollo de lenguajes de alto nivel.
LENGUAJES DE ALTO NIVEL

Los lenguajes de alto nivel suelen utilizar términos ingleses del tipo LIST, PRINT u OPEN
como comandos que representan una secuencia de decenas o de centenas de
instrucciones en lenguaje máquina. Los comandos se introducen desde el teclado, desde
un programa residente en la memoria o desde un dispositivo de almacenamiento, y son
interceptados por un programa que los traduce a instrucciones en lenguaje máquina.
Los programas traductores son de dos tipos: intérpretes y compiladores. Con un
intérprete, los programas que repiten un ciclo para volver a ejecutar parte de sus
instrucciones, reinterpretan la misma instrucción cada vez que aparece. Por consiguiente,
los programas interpretados se ejecutan con mucha mayor lentitud que los programas en
lenguaje máquina. Por el contrario, los compiladores traducen un programa íntegro a
lenguaje máquina antes de su ejecución, por lo cual se ejecutan con tanta rapidez como si
hubiesen sido escritos directamente en lenguaje máquina.
Se considera que fue la estadounidense Grace Hopper quien implementó el primer
lenguaje de ordenador orientado al uso comercial. Después de programar un ordenador
experimental en la Universidad de Harvard, trabajó en los modelos UNIVAC I y UNIVAC II,
desarrollando un lenguaje de alto nivel para uso comercial llamado FLOW-MATIC. Para
facilitar el uso del ordenador en las aplicaciones científicas, IBM desarrolló un lenguaje
que simplificaría el trabajo que implicaba el tratamiento de fórmulas matemáticas
complejas. Iniciado en 1954 y terminado en 1957, el FORTRAN (acrónimo de Formula
Translator) fue el primer lenguaje exhaustivo de alto nivel de uso generalizado.
En 1957 una asociación estadounidense, la Association for Computing Machinery
comenzó a desarrollar un lenguaje universal que corrigiera algunos de los defectos del
FORTRAN. Un año más tarde fue lanzado el ALGOL (acrónimo de Algorithmic Language),
otro lenguaje de orientación científica. De gran difusión en Europa durante las décadas de
1960 y 1970, desde entonces ha sido sustituido por nuevos lenguajes, mientras que el
FORTRAN continúa siendo utilizado debido a las gigantescas inversiones que se hicieron
en los programas existentes.
El COBOL (acrónimo de Common Business Oriented Language) es un lenguaje de
programación para uso comercial y empresarial especializado en la organización de datos
y manipulación de archivos, y hoy día está muy difundido en el mundo empresarial.
El lenguaje BASIC (acrónimo de Código de Instrucciones Simbólicas de Uso General para
Principiantes) fue desarrollado en el Dartmouth College a principios de la década de 1960
y está dirigido a los usuarios de ordenador no profesionales. Este lenguaje se universalizó
gracias a la popularización de los microordenadores en las décadas de 1970 y 1980.
Calificado de lento, ineficaz y poco estético por sus detractores, BASIC es sencillo de
aprender y fácil de utilizar. Como muchos de los primeros microordenadores se vendieron
con BASIC incorporado en el hardware (en la memoria ROM), se generalizó el uso de
este lenguaje.
Aunque existen centenares de lenguajes informáticos y de variantes, hay algunos dignos
de mención, como el PASCAL, diseñado en un principio como herramienta de enseñanza,
hoy es uno de los lenguajes de microordenador más populares; el Logo fue desarrollado
para que los niños pudieran acceder al mundo de la informática; el C, un lenguaje de Bell
Laboratories diseñado en la década de 1970, se utiliza ampliamente en el desarrollo de
programas de sistemas, al igual que su sucesor, el C++. El LISP y el PROLOG han
alcanzado amplia difusión en el campo de la inteligencia artificial.

EVOLUCIÓN FUTURA
Una tendencia constante en el desarrollo de las computadoras es la microminiaturización,
iniciativa que tiende a comprimir más elementos de circuitos en un espacio de chip cada
vez más pequeño. Además, los investigadores intentan agilizar el funcionamiento de los
circuitos mediante el uso de la superconductividad, un fenómeno de disminución de la
resistencia eléctrica que se observa cuando se enfrían los objetos a temperaturas muy
bajas.
Las redes informáticas se han vuelto cada vez más importantes en el desarrollo de la
tecnología de computadoras.
Las redes son grupos de computadoras interconectados mediante sistemas de
comunicación. La red pública Internet es un ejemplo de red informática planetaria. Las
redes permiten que las computadoras conectadas intercambien rápidamente información
y, en algunos casos, compartan una carga de trabajo, con lo que muchas computadoras
pueden cooperar en la realización de una tarea. Se están desarrollando nuevas
tecnologías de equipo físico y soporte lógico que acelerarán los dos procesos
mencionados.
Otra tendencia en el desarrollo de computadoras es el esfuerzo para crear computadoras
de quinta generación, capaces de resolver problemas complejos en formas que pudieran
llegar a considerarse creativas. Una vía que se está explorando activamente es el
ordenador de proceso paralelo, que emplea muchos chips para realizar varias tareas
diferentes al mismo tiempo. El proceso paralelo podría llegar a reproducir hasta cierto
punto las complejas funciones de realimentación, aproximación y evaluación que
caracterizan al pensamiento humano. Otra forma de proceso paralelo que se está
investigando es el uso de computadoras moleculares.
En estas computadoras, los símbolos lógicos se expresan por unidades químicas de ADN
en vez de por el flujo de electrones habitual en las computadoras corrientes. Las
computadoras moleculares podrían llegar a resolver problemas complicados mucho más
rápidamente que las actuales supercomputadoras y consumir mucha menos energía.

CONCEPTOS BÁSICOS
COMPUTACIÓN
es la ciencia encargada de estudiar los sistemas, más precisamente computadoras, que
automáticamente gestionan información.
COMPUTADORA U ORDENADOR
Máquina electrónica capaz de almacenar información y tratarla automáticamente
mediante operaciones matemáticas y lógicas controladas por programas informáticos.
ESQUEMA ESTRUCTURAL DE UNA COMPUTADORA

De acuerdo con el modelo de von Neumann, las computadoras están integradas por:
 Unidad Central de Proceso
 Unidades de entrada
 Unidades de salida
 Unidades de memoria
PROGRAMACIÓN
Es la acción de programar que implica ordenar, estructurar o componer una serie de
acciones cronológicas para cumplir un objetivo. La programación puede ser aplicado
para eventos sociales, a medios de comunicación y al mundo informático de las
computadoras.
ALGORITMO
Un algoritmo se define como un método que se realiza paso a paso para solucionar un
problema que termina en un número finito de pasos.
Ejemplo de algoritmo:
Receta para preparar atole(algoritmo)
1.-Encender la estufa.
2.-Colocar una olla y agregar la leche después ponerla a hervir.
3.-En un recipiente pequeño agregar un poco de leche para disolver la maicena.
4.-Una vez disuelta agregar la maicena a la olla.
5.-Agregar una raja de canela.
6.-Agregar azúcar.

7.-Con una cuchara disolver el atole para que no se pegue.
8.-Dejar hervir por 15 minutos aproximadamente.
SALIDA El atole está listo.
DIAGRAMA DE FLUJO
Un diagrama de flujo representa la esquematización gráfica de un algoritmo.
Es una forma esquemática de representar ideas y conceptos en relación. Frecuentemente
se utiliza para especificar algoritmos de manera grafica.
Ejemplo de diagrama de flujo:
PSEUDOCÓDIGO
Es una descripción de un algoritmo de alto nivel, que emplea una mezcla de lenguaje
natural con algunas convenciones sintácticas propias de lenguajes de programación,
como asignaciones, ciclos y condicionales.
Ejemplo de pseudocódigo:

.
CARACTERÍSTICAS DE LOS ALGORITMOS
El algoritmo debe tener las siguientes características:

Tener un principio
Ser simples, claros, precisos y exactos
Tener un orden lógico
Debe ser finito o tener un fin
LA DEFINICIÓN DE UN ALGORITMO
Debe tener 5 partes:

Inicio
Entrada
Proceso
Salida
ESTRUCTURAS ALGORITMICAS
Son un grupo de formas de trabajo que permiten mediante la manipulación de variables, realizar
ciertos procesos específicos que nos llevan a la solución de problemas.
Se clasifican en:
Asignación
Secuenciales Entrada
Salida
Simples
ESTRUCTURAS Condicionales
ALGORITMICAS
Múltiples
Hacer para
Hacer mientras
Cíclicas
Repetir hasta
METODOLOGÍA DE SOLUCIÓN DE PROBLEMAS

Existen muchos tipos de metodologías, como la metodología de investigación,
metodología de enseñanza-aprendizaje, etc., así como la metodología de solución de
problemas, que aplicamos constantemente en la vida diaria. Pero en este caso
hablaremos específicamente de la solución de problemas que podemos resolver mediante
el uso de la computadora.

La resolución de los problemas consta de cinco etapas que garantizan la llegada correcta
a la solución: identificación del problema, planteamiento de alternativas de solución,
elección de una alternativa, desarrollo de la solución y evaluación de ésta.
1. Identificación del problema
2. Planteamiento de alternativas de solución
3. Elección de una alternativa
4. Desarrollo de la solución
5. Evaluación de la solución
Ejemplo:
Planteamiento:
Si 3 libros cuestan $320.50, ¿cuántos se pueden comprar con $4500.00?
Identificación del problema:
Entrada:
Costo de 3 libros = $320.50
Cantidad de dinero con el que se cuenta = $4500.00.
Salida:
Total de libros que se pueden comprar con $4500.00.
Alternativas de solución:
Alternativa 1
$4500.00/320.50 = 14
14*3 = 42
Alternativa 2
320.50/3 = 106.83
4500/106.83 = 42
Alternativa 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 320.50 = 3
$ 4487.00 = 42
Elección de una alternativa:
Alternativa 1 es la mas adecuada.
$4500.00/320.50 = 14
14*3 = 42 Se pueden comprar 42 libros
Selecciona la alternativa que se considere más completa, sencilla o mejor, según las
necesidades o el criterio de elección.

.
SISTEMAS NUMÉRICOS
Un sistema numérico es un conjunto de símbolos y reglas que se utilizan para
representar datos numéricos o cantidades. Se caracterizan por su base que indican el
número de símbolos distinto que utiliza y además es el coeficiente que determina cual es
el valor de cada símbolo dependiendo de la posición que ocupe.
En matemáticas, son varios los sistemas de notación que se han usado o se usan para
representar cantidades abstractas denominadas números. Un sistema numérico está
definido por la base que utiliza. La base es el número de símbolos diferentes, o guarismos
necesarios para representar un número cualquiera de los infinitos posibles, en el sistema.
Por ejemplo, el sistema decimal, utilizado hoy de forma universal (con la excepción de las
computadoras), necesita diez símbolos diferentes o dígitos para representar un número y
es, por tanto, un sistema numérico en base 10.
A lo largo de la historia se han usado multitud de sistemas numéricos. En realidad,
cualquier número mayor que 1 puede ser utilizado como base. Algunas civilizaciones
usaban sistemas basados en los números 3, 4 o 5. Los babilonios utilizaron el sistema
sexagesimal, basado en el número 60, y los romanos (en ciertas aplicaciones) el sistema
duodecimal, con el número 12 como base. Los mayas utilizaban el sistema vigesimal,
basado en el número 20. El sistema binario, ó base 2, fue usado por algunas tribus
antiguas y junto con el sistema en base 16 se usa en la actualidad en las computadoras.
Los sistemas de numeración son, conjuntos de dígitos usados para representar
cantidades, así se tiene los sistemas de numeración: Decimal, Binario, Octal.
Hexadecimal, Romano, etc. Los cuatro primeros se caracterizan por tener una base
(numero de dígitos diferentes: diez, dos, ocho y dieciséis respectivamente).
El sistema de numeración binario es el mas importante en los sistemas digitales, en el
sistema decimal la importancia radica en que se utiliza universalmente para representar
cantidades fuera de un sistema digital. Esto significa que habrá situaciones en las cuales
los valores decimales tengan que convertirse en valores binarios antes de que se
introduzcan en el sistema digital.
En computación sólo se reconocen cuatro sistemas de numeración: el decimal, el binario,
el octal y el hexadecimal.
SISTEMA NUMÉRICO DECIMAL

Consiste en una combinación de diez dígitos (0, 1, 2, 3, 4, 5, 6, 7, 8 y 9) por
consecuencia su base es 10.
Ejemplo:
309832310 Se representa de la siguiente manera:
...........
3 × 106 + 0 × 105 + 9 × 104+ 8 × 103 + 3 × 102 + 2 × 101+ 3 × 100, o 3 × 1

= 3 x 1000000 + 0 x 100000 + 9 x 10000 + 8 x 1000 + 3 x 100 + 2 x 10 + 3 x 1
= 3000000 + 0 + 90000 + 8000 + 300 + 20 + 3 = 3098832310
Valores posiciónales. La posición de una cifra indica el valor de dicha cifra en función de
los valores exponenciales de la base.
SISTEMA NUMERICO BINARIO (Lenguaje maquina).

El sistema binario desempeña un importante papel en la tecnología de las
computadoras. Puesto que sólo se necesitan dos dígitos (o bits), el sistema binario se
utiliza en las computadoras. Un número binario cualquiera se puede representar, por
ejemplo, con las distintas posiciones de una serie de interruptores. La posición
"encendido" corresponde al 1, y "apagado" al 0. Además de interruptores, también se
pueden utilizar puntos imantados en una cinta magnética o disco: un punto imantado
representa al dígito 1, y la ausencia de un punto imantado es el dígito 0.
Los biestables dispositivos electrónicos con sólo dos posibles valores de voltaje a la
salida y que pueden saltar de un estado al otro mediante una señal externa. También se
pueden utilizar para representar números binarios. Los circuitos lógicos realizan
operaciones con números en base 2. La conversión de números decimales a binarios
para hacer cálculos, y de números binarios a decimales para su presentación, se
efectúan electrónicamente.
La palabra bit se forma del acrónimo binary digit (dígito binario)

Bit: es la mínima cantidad de información.
El lenguaje maquina se interpreta mediante pulsoa electrónicos Altos = 1 y bajos =0

Ejemplo:
SISTEMA NUMÉRICO OCTAL

Consta de ocho digitos (0, 1, 2, 3, 4,5, 6,7) y su base es 8.
SISTEMA NUMÉRICO HEXADCIMTAL

Consta de dieciséis digitos ((0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A =diez, B =once, C =doce, D =
trece, E = catorce y F = quince )) y su base es 16.
CONVERSIONES DE SISTEMAS NUMÉRICOS

Las computadoras solo reconocen los sistemas numéricos (decimal,binario,octal y
hexadecimal). Por consecuencia es muy importante conocer los métodos para escribir
cifras de un sistema a otro sin ninguna dificultad.
CONVERSIÓN DE DECIMAL A BINARIO.

Regla. Se divide el número decimal correspondiente entre el número 2, así
sucesivamente hasta que el último cociente sea igual a 1, tomado como base este último
cociente y todos los residuos(0 y 1) de derecha a izquierda, para obtener el número
binario equivalente. Nota: para mayor comodidad las divisiones se deben realizar en
forma horizontal.
Ejemplos:
210 = ( ?)2 = 102
2/2 = 1 Cociente = 1 Resultado = 102
Residuo = 0

5010 = (?)2 = 1100102
50/2 = 25/2 = 12/2 = 6/2 = 3/2 = 1 Último cociente = 1 Resultado = 110010 2
Residuos 0 1 0 0 1
CONVERSIÓN DE BINARIO A DECIMAL

Regla. Tomando como base el bit menos significativo de la extrema derecha hacia la
izquierda, la base 2 se eleva a la potencia 0 y se multiplica por el bit correspondiente,
mas la base 2 elevada a la potencia 1 y así sucesivamente hasta la potencia n, los
resultados se suman para obtener el número decimal equivalente.
Ejemplo:
1110010101102 = ( ?)10 = 367010
1 1 1 0 0 1 0 1 0 1 1 0
211 x 1+210 x 1+29 x 1 +28 x 0+27 x 0+26 x 1+25 x 0 + 24 x 1 + 23 x 0 + 22 x 1 +21 x 1 + 20 x 0

= 2048 + 1024 + 512 + 0 + 0 + 64 + 0 + 16 + 0 + 4 + 2 + 0 = 367010
.
CONVERSIÓN DE DECIMAL A BINARIO SIN UTILIZAR LA DIVISIÓN
De acuerdo a lo establecido en la conversión de sistema binario a decimal, se llego a la
conclusión de que los valores de la base 2 elevada a la potencia 0 y así sucesivamente
hasta la la base 2 elevada a la potencia n, siempre serán valores constantes por su
multiplicación por 1.
Ejemplo:
2n + . + . + 210 + 29 + 28 + 27 + 26 + 25 + 24 + 23 + 22 + 21 + 20
= 2n + . + . 1024+512+256+128+64+32+16+8+4+2+1 Estos valores siempre serán fijos.
Regla: para convertir una cifra decimal a binaria, se busca un valor de los ya establecidos
que sea menor al número decimal dado, y así sucesivamente hasta el valor 1, los valores
que den la suma del decimal se activarán en 1 y los otros valores en 0. Dando como
resultado el número binario equivalente.
Ejemplo:
45610 = (?)2 = 1110010002
256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 Se encienden los focos en los valores 256, 128, 64 y 8
estos se activan en 1 y los demas en 0. = 111001000 2
1 1 1 0 0 1 0 0 0 = 111001000 2
256 + 128 + 64 + 0 + 0 + 0 + 8 + 0 + 0 + 0 = 45610
CONVERSIÓN DE BINARIO A DECIMAL

Regla: se aplica la misma regla pero en sentido inverso, ahora se suman los valores
decimales que que estén en 1.
Ejemplo:
110101101101101112 = ( ? )10 = 11000710
1 1 0 1 0 1 1 0 1 1 0 1 1 0 1 1 1
65536+32768+0+8192+0+2048+1024+0+ 256+128+0+32+16+0+4+2+1 = 11000710
CONVERSIÓN DE DECIMAL A OCTAL

Regla: Se aplica la misma regla que en los sistemas anteriores, la única diferencia es que
el decimal se divide por la base 8.
Nota. En el sistema octal sólo se reconocen los números del 0 al 7.
Ejemplo:
34610 = ( ? )8 = 5328 346/8 = 43/8 = 5 Último cociente
Residuos = 2 3 = 5328
.
CONVERSIÓN DE OCTAL A DECIMAL
Regla: Comenzando de la derecha hacia la izquierda, se eleva la base 8 a la potencia 0 y
se multiplica por el dígito correspondiente y así sucesivamente hasta la enésima potencia,
los resultados se suman para obtener el número decimal deseado.
Ejemplo:
5328 = ( ? )10 = 34610
532
82 x 5 + 81 x 3 + 80 x 2 = 64x5 + 8x3 + 1x2 = 320 + 24 + 2 = 34610
CONVERSIÓN DE BINARIO A OCTAL

Regla: Comenzando de la derecha hacia la izquierda, se seleccionan paquetes de tres
bits, estos se convierten a su decimal correspondiente, los números obtenidos se ordenan
de izquierda a derecha dando como resultado el número octal correspondiente.
Nota: si al último paquete le falta uno o dos bits éste se rellena con ceros.
Ejemplo:
11110101011101110110101012 = ( ? )8 = 1725673258
001 111 010 101 110 111 011 010 1012
1 7 2 5 6 7 3 2 5
CONVERSIÓN DE DECIMAL A HEXADECIMAL

Regla: Se utiliza la misma que en los sistemas anteriores, la diferencia es la base 16 y si
los cociente o los residuo son iguales o mayores que 10 hasta el número 15, estos se
sustituyen por su letra equivalente.
Ejemplo:
Condiciones: A = 10, B = 11, C = 12, D = 13, E = 14 y F = 15
1810 = ( ? )16 = 2016
18/16 = 2 Cociente = 2 Resultado = 2016
Residuo = 0
274810 = ( ? )16 = ABC16
2748/16 = 171/16 = 10 Cociente = 2 Resultado = ABC16
Residuos = 12 11
CONVERSIÓN DE HEXADECIMAL A DECIMAL

Regla: se aplica la misma que en los sistemas anteriores, la diferencia es la base 16.
Ejemplo:
ABC16 = ( ? )
A B C
162x10 + 161x11 + 160x12 = 256x10 + 16x11 + 1x12 = 2560 + 176 + 12 = 274810

.
CONVERSIÓN DE BINARIO A HEXADECIMAL
Regla: se utiliza la misma regla que en la conversión de binario a octal, la diferencia es
que se seleccionan paquetes de 4 bits y los decimales resultantes de los paquetes si son
iguales o mayores que 10 hasta el número 15 estos se sustituyen por sus letras
correspondientes. Nota: si al último paquete le faltan uno, dos o tres bits éste se rellena
con ceros.
Ejemplo: 0010111011101111011110111101111001012 = (?)16
8421 8421 8421 8421 8421 8421 8421 8421 8421
0010 1110 1110 1111 0111 1011 1101 1110 01012 = 2EEF7BDE516
2 14 14 15 7 11 13 14 5
2 E E F 7 B D E 5
Los sistemas numéricos octal y hexadecimal se utilizan en computación para reducir cifras
binarias. Los números binarios largos se pueden expresar de forma concisa en sistemas
numéricos con bases más altas que el sistema numérico binario.
Ejemplos:
OCTAL 11110101011101110110101012 = ( ? )8 = 1725673258

001 111 010 101 110 111 011 010 1012
1 7 2 5 6 7 3 2 5
27 cifras binarias se reducen a 9 cifras octales.
HEXADECIMAL
0010 1110 1110 1111 0111 1011 1101 1110 01012 = 2EEF7BDE516
2 14 14 15 7 11 13 14 5
2 E E F 7 B D E 5
36 cifras binarias se reducen a 9 cifras hexadecimales.
El sistema numérico hexadecimal, es el que mas utilizado para reducir cifras binarias en
computación.
Aplicación de programación en lenguaje C para la conversión de los sistemas numéricos
decimal, binario, octal y hexadecimal.
/*Programa que convierte un numero decimal a binario ,octal y hexadecimal utilizando la

función itoa que pertenece a la librería #include<stdlib.h>*/
#include <stdio.h>
#include<stdlib.h>
main()
{
int decimal,base;
char cadena[63];//cadena maximo 63 bits
printf("Ingrese el numero DEC: "); scanf("%d",&decimal);
printf("Ingrese la base [2,8,16]: "); scanf("%d",&base);
itoa(decimal,cadena,base);

printf("El numero decimal en base %d es :%s\n",base,cadena);
return 0;
}
TABLA QUE REPRESENTA LOS SISTEMAS NUMÉRICOS EN DEC, BIN, OCT Y HEX
Decimal Binario Octal Hexadecimal

0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
16 10000 20 10
17 10001 21 11
18 10010 22 12
19 10011 23 13
20 10100 24 14
21 10101 25 15
22 10110 26 16
23 10111 27 17
24 11000 30 18
25 11001 31 19
26 11010 32 1A
27 11011 33 1B
28 11100 34 1C
29 11101 35 1D
30 11110 36 1E
31 11111 37 1F
32 100000 40 20
33 100001 41 21
34 100010 42 22
35 100011 43 23
36 100100 44 24
37 100101 45 25
38 100110 46 26
39 100111 47 27
40 101000 50 28
41 101001 51 29
42 101010 52 2A

43 101011 53 2B
44 101100 53 2C
45 101101 54 2D
CODIGO ASCII
La gran mayoría de las computadoras personales, utilizan el código ASCII (Código
Estándar Americano para el Intercambio de Información) como conjunto de caracteres,
donde cada carácter individual se codifica numéricamente con su propia combinación de
caracteres de 8 bits llamados Bytes. Donde a cada carácter le corresponde un número
decimal. Los caracteres están ordenados en forma consecutiva. Por ejemplo, los dígitos
se ordenan consecutivamente en su propia secuencia numérica (0 a 9), y las letras se
disponen en orden alfabético precediendo las mayúsculas a las minúsculas.
El código ASCII consiste en una combinación de 0 a 255 caracteres o bytes.
Se clasifica en: ASCII Normal(0 a 127 Bytes) y Extendido(128 a 255 Bytes)
Carácter: es una letra, un número o un signo o un byte.
Lenguaje C solo reconoce el código ASCII normal.
BYTE: es una colección o paquete de 8 bits y representa un carácter.

Bit: es la minima cantidad de información en computación
El código ASCII es muy práctico porque nos permite tener acceso a cualquier carácter con
solo presionar la tecla Alt y el número decimal correspondiente en el teclado numérico.
La palabra bit se forma del acrónimo binary digit
Ejemplo:
0 0 0 0 0 0 0 0 = 1 Byte o carácter
b7 b6 b5 b4 b3 b2 b1 b0
27x0 + 26 x0 + 25 x0 + 24 x0 +23 x0 + 22 x0 + 21 x0 + 20x0 = 128x0+64x0+32x0+16x0+8x0+4x0+
2x0+1x0 = 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 = 0
.. = 1 Byte o carácter
1 1 1 1 1 1 1 1
b7 b6 b5 b4 b3 b2 b1 b0
27x1 + 26 x1 + 25 x1 + 24 x1 +23 x1 + 22 x1 + 21 x1 + 20x1 = 128x1+64x1+32x1+16x1+8x1+4x1+
2x1+1x1 = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255
El número de combinaciones que se pueden realizar en un byte son de 0 hasta 255. La
formula general es: 28 -1 = 256 - 1 = 255 combinaciones.
El código ASCII fue diseñado de tal manera que cada carácter o byte represente un
número decimal. Por ejemplo, A = 65, ..Z = 90, a = 97, b = 98,....z = 122 y otros signos.
La computadora en su interior no entiende números decimales, ni letras ni símbolos. Solo
entiende el sistema binario llamado lenguaje maquina que consiste en trenes de pulsos
altos bajos de 8 bits (bytes). ALTO = = 1 y BAJO = = 0
En el interior de la maquina los bits se representan por pulsos electrónicos ALTOS y
BAJOS . Por ejemplo, al presionar cualquier carácter del teclado en el interior de la
maquina se activa un tren de 8 pulsos electrónicos ALTOS y BAJOS. Estos pulsos se
codifican y decodifican y al final del proceso se visualiza en pantalla el carácter elegido.
Ejemplo:
Convertir a lenguaje maquina el siguiente texto.
Decimal Binario Lenguaje maquina Texto

72 01001000 H

111 01101111 o
108 01101100 l
97 01100001 a
El código ASCII es muy práctico porque nos permite tener acceso a cualquier carácter con
solo presionar la tecla Alt y el número decimal correspondiente en el teclado numérico.
Ejemplos:
Alt + 85 = U, Alt + 122 = z, Alt + 94 = ^, Alt + 124 = |, etc.
El código ASCII se clasifica en normal(0 a 127 bytes) y Extendido(128 a 255 bytes).
CÓDIGO ASCII NORMAL(0 a 127 BYTES)
Dec
Sím
Hex bol DecHexSímbolo DecHexSímbolo DecHexSímbolo
o
16 10 DLE 32 20 (space) 48 30 0
0 0 NUL 17 11 DC1 33 21 ! 49 31 1
1 1 SOH 18 12 DC2 34 22 " 50 32 2
2 2 STX 19 13 DC3 35 23 # 51 33 3
3 3 ETX 20 14 DC4 36 24 $ 52 34 4
4 4 EOT 21 15 NAK 37 25 % 53 35 5
5 5 ENQ 22 16 SYN 38 26 & 54 36 6
6 6 ACK 23 17 ETB 39 27 ' 55 37 7
7 7 BEL 24 18 CAN 40 28 ( 56 38 8
8 8 BS 25 19 EM 41 29 ) 57 39 9
9 9 TAB 26 1A SUB 42 2A * 58 3A :
10 A LF 27 1B ESC 43 2B + 59 3B ;
11 B VT 28 1C FS 44 2C , 60 3C <
12 C FF 29 1D GS 45 2D - 61 3D =
13 D CR 30 1E RS 46 2E . 62 3E >
14 E SO 31 1F US 47 2F / 63 3F ?
15 F SI
DecHexSímbolo DecHexSímbolo DecHexSímbolo Dec Hex Símbolo
64 40 @ 80 50 P 96 60 ` 112 70 p
65 41 A 81 51 Q 97 61 a 113 71 q
66 42 B 82 52 R 98 62 b 114 72 r
67 43 C 83 53 S 99 63 c 115 73 s
68 44 D 84 54 T 100 64 d 116 74 t
69 45 E 85 55 U 101 65 e 117 75 u
70 46 F 86 56 V 102 66 f 118 76 v
71 47 G 87 57 W 103 67 g 119 77 w
72 48 H 88 58 X 104 68 h 120 78 x
73 49 I 89 59 Y 105 69 i 121 79 y
74 4A J 90 5A Z 106 6A j 122 7A z
75 4B K 91 5B [ 107 6B k 123 7B {|
76 4C L 92 5C \ 108 6C l 124 7C
}
77 4D M 93 5D ] 109 6D m 125 7D
~
78 4E N 94 5E ^ 110 6E n 126 7E

79 4F O 95 5F _ 111 6F o 127 7F
CÓDIGO ASCII EXTENDIDO(128 a 255 BYTES)
El código ASCII extendido(128 al 255 bytes), se asignan a conjuntos de caracteres que

varían según los fabricantes de computadoras y programadores de software. Estos
códigos no son intercambiables entre los diferentes programas y computadoras como los
caracteres ASCII normal(0 a 127 bytes)
Programa de ejemplo:
//programa que visualiza el codigo ASCII normal y extendido (0 a 255 bytes)
#include<stdio.h>
main()
{
int cont;
for(cont= 0;cont<=255;++cont)
printf("%d %c\t",cont,cont);
return 0;
}

.
PUERTAS O COMPUERTAS LÓGICAS BÁSICAS
Las compuertas lógicas son elementos básicos en los sistemas de computación. Estas
operan con números binarios, por consecuencia a las compuertas lógicas también se les
llama compuertas lógicas binarias. Todos los voltajes usados en las compuertas lógicas
serán pulsos de onda cuadrada ALTOS o BAJOS. Un pulso ALTO equivale a un 1 binario
y un pulso BAJO equivaldría a un 0 binario. Las compuertas lógicas son circuitos
electrónicos hechas a base de transistores, diodos y resistencias diseñadas para solo
responder a pulsos ALTOS = 1 = 5 volts y BAJOS = 0 = 0 volts o (tierra).
Existen tres compuertas lógicas básicas, de estas se derivan otras mas complicadas. A
estas compuertas lógicas se les denomina como: compuerta lógica NOT, compuerta
lógica AND y compuerta lógica OR.
COMPUERTA LÓGICA NOT (Inversora o de negación)

Entrega a la salida un 1 si la entrada es 0 y viceversa. Su número de combinaciones es
21=2, el exponente 1 indica el número de entradas.
De acuerdo a las reglas de álgebra booleana
0= 1y 1=0 La expresión 0 se lee cero negado es igual a 1 y viceversa

Si A = 1 entonces A = 0
A= A Esta expresión se lee A doble negada es igual a A

Símbolo tradicional Tabla de verdad Expresión booleana Símbolo IEC
A S
Entrada A o Salida S 0 1 S= A
1 0
Ejemplo:
A 1 o0 o 1 S Si A =1 S = 1 Esto es equivalente a: 1 = 1
COMPUERTA LÓGICA AND ( y ) ( Todo o nada)

Entrega a la salida 1 si las entradas son igual a 1 y, 0 si las entradas son igual a cero o
diferentes.
Ejemplo:
Número de combinaciones 22 = 4
Símbolo tradicional Interpretación. Tabla de verdad Expresión booleana Símbolo IEC
A S = 0.0 = 0 B A S S = A.B
S 0.1 = 0 0 0 0
B 1.0 = 0 0 1 0
1.1 = 1 1 0 0
1 1 1

La compuerta AND se puede comprara con un circuito eléctrico, poniendo los
interruptores en serie para encender un foco.
Ejemplo:
A B
Cerrado = 1 Abierto = 0 Foco encendido = 1
Si el interruptor A se cierra y el interruptor B se mantiene
~ S abierto el foco no se enciende. Sí sin embargo, se
cierran los dos interruptores el foco se encenderá.
. COMPUERTA LÓGICA OR ( o )
Esta entrega a la salida 0 si las entradas son 0 y, 1 si las entradas son diferentes o igual a
1.
Ejemplo:
Número de combinaciones 22 = 4
Símbolo tradicional Interpretación Tabla de verdad Expresión booleana Símbolo IEC
S = 0+0 = 0 B A S S= A+B
A 0+1 = 1 0 0 0
------ S 1+0 = 1 0 1 1
B 1+1 = 1 1 0 1
1 1 1
La compuerta OR se puede comparar con un circuito eléctrico poniendo los interruptores
en paralelo para encender un foco.
Ejemplo:
A
Cerrado = 1 Abierto = 0 Foco encendido = 1
Si el interruptor A se cierra y el interruptor B se mantiene
B S abierto el foco se enciende. Con una sola condición que
~ se cumpla el foco se encenderá.
COMPUERTA LÓGICA NAND (No y )

Entrega 1 a la salida si las entradas son 0 o diferentes, y 0 si las entradas son igual a 1.
Ejemplo:
B A S
A S = 0.0 = 0 = 1 0 0 1 S = A.B
o---- S 0.1 = 0 = 1 0 1 1
B 1.0 = 0 = 1 1 0 1
1.1 = 1 = 0 1 1 0
COMPUERTA LÓGICA NOR ( No O )

Entrega 0 a la salida si las entradas son diferentes o igual a 1 y, 1 si las entradas son
igual a 0.
Ejemplo:
S = 0+0 = 0 = 1 B A S S= A+B
A 0+1 = 1 = 0 0 0 1
o----- S 1+0 = 1 = 0 0 1 0
B 1+1 = 1 = 0 1 0 0
1 1 0

.
COMPUERTA LÓGICA OR EXCLUSIVA XOR
Entrega 1 a la salida si las entradas son impares en 1 y, 0 si las entradas son igual a 0 o
pares en 1.
Ejemplo:
S = 00 = 0 B A S S= AB
A 01 = 1 0 0 0
----- S 10 = 1 0 1 1
B 11 = 0 1 0 1
1 1 0
COMPUERTA LÓGICA NOR EXCLUSIVA XNOR

Entrega 1 a la salida si las entradas son igual a 0 o pares en 1 y, 0 si las entradas son
impares en 1 .
Ejemplo:
S = 00 = 1 B A S S= AB
A 01 = 0 0 0 1
o----- S 10 = 0 0 1 0
B 11 = 1 1 0 0
1 1 1
La combinación de las compuertas lógicas permite la codificación y de codificación de los

pulsos electrónicos ALTOS = 1 y BAJOS = 0, para la visualización de los caracteres en la
pantalla de salida.
Ejemplo:

.
TABLA LAS PRINCIPALES COPUERTAS LÓGICAS BÁSICAS
Puerta Símbolo Símbolo IEC Función Simulación Tabla de

tradiciona verdad
l

Las compuertas logicas AND, OR y NOT son la base escencial para la construccion de
cualquier circuito digital.En base a estas se construyen las otras: NAND, NOR XOR y
XNOR.
COMPARACION DE LAS PUERTAS LOGICAS CON LOS OPERADORES LOGICOS DE C

Las compuertas lógicas se comparan con los operadores lógicos utilizados en lenguaje C
para la redacción de programas.
Compuerta lógica Operador de lenguaje C

NOT !
AND &&
OR ||
NAND !&&
NOR !||
XOR ^
XNOR
.
/* programa que compara las compuertas lógicas con los operadores lógicos de lenguaje
C*/
#include <stdio.h>
main()

{
int a = 15, b = 10, c,d,e,f,g;
c = !(a<b); //Compuerta logica NOT(!)
d = (a > b) && (a < b); //Compuerta logica AND(&&)
e = (b < a) || (a < b); //Compuerta logica OR(||)
f = !( (a > b) && (a < b)); //Compuerta logica NAND(&&)
g= !( (b < a) || (a < b)); //Compuerta logica NOR(||)
printf( "!(a < b) da como salida %d\n", c );
printf( "(a > b) && (a < b); da como salida %d\n",d);
printf( "(b< a) || (a < b) da como salida %d\n",e);
printf( "!((a > b) && (a < b)); da como salida %d\n",f);
printf( "!((b< a) || (a < b)) da como salida %d\n",g);
return 0;
}
Cierto = 1
True = 1
Falso = 0
False = 0
.
CAPÍTULO 2

INTRODUCCIÓN AL LENGUAJE C
El lenguaje C, es tipo lenguaje estructurado de propósito general parecido a otros
lenguajes de programación como: PASCAL, BASIC, FORTRAN, etc. Sus instrucciones
son muy parecidas incluyendo sentencias como if, else, for, do y while. C es un lenguaje
de alto nivel y posee sentencias y funciones que simplifican su funcionamiento.Tambien
se tiene la posibilidad de programar a bajo nivel (como en el lenguaje ensamblador
tocando los registros memoria).
El lenguaje de programación C, está caracterizado por ser de uso general, con una
sintaxis sumamente compacta y de alta portabilidad. Para simplificar su funcionamiento el
lenguaje C tiene incluidos archivos o librerías de funciones que pueden ser incluidas
haciendo referencia la librería que las incluye. Es decir que si queremos usar una función
para borrar la pantalla o una función de salida, tendremos que incluir en nuestro programa
los archivos o librerías a las que pertenecen dichas funciones..
Programar en C tiene una gran flexibilidad para escribir código compacto y sencillo a su
misma vez, tiene las características que permiten su uso a un nivel más bajo, cubriendo
así el vacío entre el lenguaje máquina y los lenguajes de alto nivel más convencionales.
Esta flexibilidad permite su uso en la programación de sistemas, diseño de sistemas
operativos, así como en la programación de aplicaciones por ejemplo: redactar un
programa que resuelva un complicado sistema de ecuaciones matemáticas, o un
programa que escriba facturas para clientes, etc.
Cada instrucción en C va seguida de un punto y coma (;) para decirle al compilador que
hasta ahí llega la instrucción. El punto y coma (;) simula un enter del teclado.
ANTECEDENTES HISTÓRICOS DE C
Lenguaje C o también conocido como “Lenguaje de programación de sistemas” fue
desarrollado en los años setenta por Dennis Ritchie en Bell Telephone Laboratories, inc.
Este lenguaje es el resultado de dos lenguajes anteriores, el BCPL y el B, que se
desarrollaron anteriormente. C se usó únicamente en los laboratorios Bell hasta 1978,
cuando Brian Kernighan y Dennis Ritchie publicaron una descripción definitiva del
lenguaje “K&R C“.Tras la publicación de K&R, los profesionales de las computadoras,
impresionados por las características del lenguaje C, comenzaron a promover su uso. Por
la mitad de los ochenta, la popularidad de C se había extendido por todas partes. Se
habían escrito numerosos compiladores e interpretes de C para computadoras de todos
los tamaños y se habían desarrollado muchas aplicaciones comerciales. Muchas de estas
que se habían escrito en otros lenguajes se reescribieron en C para tomar partido de su
eficiencia y portabilidad.
La mayoría de las implementaciones de C diferían en algo de la definición original de
K&R. Esto creó pequeñas incompatibilidades entre las diferentes implementaciones del
lenguaje. Debido a este problema, el Instituto Nacional Americano de Estándares (ANSI).
Estableció un comité para crear un estándar de C. Esto se logró en el año de 1990,
apareciendo Turbo C. Turbo C es un compilador rápido y eficiente, satisfaciendo así las
necesidades de una amplia variedad de programadores.
Este lenguaje de programación está orientado a los Sistemas operativos y es muy eficaz y
con él podemos crear Software de sistemas operativos como Windows, Linux y también
para aplicaciones. También sirve para experimentos informáticos, físicos, matemáticos
etc. es también muy utilizado en robótica con el que se programan simuladores, etc.
.
LENGUAJE DE PROGRAMCION

Está formado por un conjunto de símbolos y reglas sintácticas y semánticas que definen
su estructura y el significado de sus elementos y expresiones.
PROGRAMACIÓN
Es el proceso por el cual se escribe, se prueba, se depura, se compila (de ser necesario)
y se mantiene el código fuente de un programa informático.
PROGRAMA
Proyecto o planificación ordenada de las distintas partes o actividades que componen
algo que se va a realizar.
ESTRUCTURA DE UN PROGRAMA EN “C”

Todo programa en C puede incluir: directivas de procesador, declaraciones globales y
locales, la función principal main(),comentarios del programa, funciones definidas por el
usuario,instrucciones,sentencias, etc.
Las directivas son instrucciones del compilador. Todas las directivas o librerías o archivos
de cabecera comienzan con el signo (#), las mas utilizadas en C son #include y #define
no terminan en punto y coma, ya que no son instrucciones de lenguaje C.
C utiliza varios archivos o librerías a los cuales pertenecen ciertas funciones llamadas de
biblioteca o librerías, para realizar varias operaciones y cálculos de uso frecuente. Estas
funciones es encuentran almacenadas en archivos que se incluyen en el compilador. Para
acceder a estos archivos se utiliza la directiva: #include.
DIRECTIVA: #include
Su formato es: #include<archivo.h>
En la redacción de cualquir programa en C, se deben incluir todos los archivos a los que
pertenecen las funciones de biblioteca que se utilecen en su desarrollo.
Ejemplo:
//Progama de aplicación de ladirectiva #include.
#include<stdio.h>
#include<math.h>
#include<conio.h>
main()
{
float x, y,s,t;
printf(“x= \n”); /*archivo #include<stdio.h> */
scanf(“%f”,&x); //archivo#include<stdio.h>
printf(“y=\n ”);
scanf(“%f”,&y); //archivo#include<stdio.h> */
s = pow(x*y,3); //archivo #include<math.h>
t= sqrt(x); // archivo #include<math.h>
getch(); //archivo #include<conio.h>
printf(“s = %f t = %f”,s,t);
}
/*Aplicacion de las funciones system (“cls”) y Sleep( ) que pertenecen al archivo

#include <windows.h>*/
#include<stdio.h>
#include<conio.h>
#include <windows.h>
main()
{
int cont;

for(cont=0;cont<=100;++cont){
//getch();//delay = retrasar
system("cls");//En Devc++ y en Borland C es clrscr()
Sleep(1000); //1000 milisegundos = a 1 segundo.
printf("%d\t",cont);// En Borland C es delay() y en Devc++ es Sleep()
}
return 0;
}
//Programa que simula un reloj digital

#include <stdio.h>
#include <windows.h>
main()
{
int hora=0,segundo=0, minuto=0;
printf("igrese la hora y minutos: ");
scanf("%d%d",&hora,&minuto);
for(segundo = 0; segundo <60; segundo++)
{
Sleep(1000);
system("cls");
printf("\n\n\n\n\n\n\n\n\n\t\t\t\t%d : %d : %d",hora, minuto, segundo);
if(segundo == 59)
{
segundo=0;
minuto = minuto + 1;
}
if(minuto == 59)
{
segundo=0;
minuto = 0;
hora = hora + 1;
}
}
}
DIRECTIVA #define
Su formato es: #define nombre texto
Esta directiva indica al procesador que sustituya un dato por otro. Por ejemplo, la
directiva #define TRE 50 sustituirá el valor de 50 cada vez que TRE aparezca en el
programa. Tambien se le llama constante simbólica.
//Programa de aplicación de la directiva #define

#define PI 3.1416 #define CIERTO 1 #define FALSO 0
#include<stdio.h>/*Programa que calcula el área de un circulo*/
#define PI 3.1416 /* Programa de aplicación de la constante simbólica*/
main()
{
float A,r;
printf(“Introduce el valor de r: \n”);scanf(“%f”,&r);A = PI*r*r;

printf(“El resultado del Area es: %f\n”, A);
}
/*Lee un numero entero y determina si es par o impar*/

#include <stdio.h>
#define M % /* %, es el operador que obtiene el resto
de la división entera */
#define E ==
#define PE !=
#define S 1
#define N 0
int es_impar(int);
main ( )
{
int n;
printf ("Introduzca un entero: ");
scanf ("%d", &n);
if ( es_impar (n) E S )
printf ("El numero %d es impar. \n", n);
else
printf ("El numero %d no es impar. \n", n);
}
int es_impar (int q)
{
int respuesta;
if ( q M 2 PE 0 ) respuesta=S;
else respuesta=N;
return (respuesta);
}
DECLARACIONES
Una declaración consiste en un tipo de datos, seguido de uno o más nombres de
variables, finalizando en un punto y coma (;).
Todas las variables deben ser declaradas antes de ser utilizadas.
Ejemplos: char p; int a,b,c; float r1,r2; double x,y,z;
También se le pueden asignar valores iniciales a las variables dentro de la declaración de
tipo:
Ejemplos:
char p = ‘x’;
char texto[ ] = “Hola”;
int a = 3, b = 5, c;
foat x = 0.013, y = -5.2;
LAS DECLARACIONES SE CLASIFICAN EN: GLOBALES Y LOCALES

GLOBALES Indican al programador que las constantes o variables declaradas son
comunes a todas las funciones del programa, se escriben antes de la función principal
main(). También en esta zona se pueden declarar prototipos de funciones ver capitulo VI.
LOCALES Son variables o constantes que se declaran dentro de una función o cuerpo
de un programa. Estas solo pueden ser utilizadas por las sentencias de la función donde
están declaradas, fuera de dicha función, no tienen validez.
Ejemplo:
//programa que visualiza las variables globales y locales
#include<stdio.h>
int y=20; // y variable global
main ()
{
{ int x = 5;// x variable local Inicio del bloque
printf ("x = %d, y = %d\n", x, y); // Visualiza x = 5, y = 20
} // Fin del bloque
{ // Inicio del bloque
int x=10; // Esta x es local al bloque
printf ("x = %d, y = %d\n", x, y); // Visualiza x = 10, y = 20
} // Fin del bloque
{ // Inicio del bloque
int x = 30;// x variable local
printf ("x = %d, y = %d\n", x, y);/* Visualiza x = 30, y = 20 */
}// Fin del bloque
}// El valor de y no cambia porque es variable global
LA FUNCIÓN PRINCIPAL DE CABECERA main()

El único componente que es obligatorio en cada programa en C, es la función main(). En
su forma más simple esta función consiste en el nombre main, seguido por un par de
paréntesis vacíos ( ) y un par de llaves { } . Dentro de las llaves se encuentran
enunciados que forman el cuerpo principal del programa.
Bajo circunstancias normales la ejecución de un programa comienza con el primer
enunciado de main(), y termina con el último enunciado de main().
En la función main() se desarrolla todo el código del programa, las llamadas a funciones
procedimientos etc.
Siendo la primera en ser llamada cuando comienza la ejecución de programa. La función
main(), es parte esencial en un programa en C.
Su formato es:
main()
{
secuencia de sentencias Cuerpo de la función o estructura o sentencia compuesta

o bloque de sentencias
…………………………….
}
COMENTARIOS
La inclusión de comentarios en un programa es una saludable práctica, como lo
reconocerá cualquiera que haya tratado de leer un listado elaborado por otro programador
ó por sí mismo, varios meses atrás. Para el compilador, los comentarios son inexistentes,
por lo que no generan líneas de código, permitiendo abundar en ellos tanto como se
desee.
Los comentarios se escriben entre los delimitadores /* y */. Por ejemplo: /*En C Este es
un comentario */. Parrafo completo. Y // comrntario una sola línea.
En C++ los comentarios se se preceden con dos diagonales //. Por ejemplo: //En C++
esto es un comentario en C tambien se pueden utilizar las //.
.
MUESTRA DE LA ESTRUCTURA DE UN PROGRAMA EN C

/* Comentarios*/ Párrafo completo // Comentarios Una sola línea.
Zona de ficheros de cabecera de las librerías# include <archivo.h> // h de header =
Encabezado y de las directivas #include o constantes simbólicas: Zona de prototipos de
funciones
Zona de deslaraciones globales
main() Cabecera principal
{ //llave de inicio del programa
Zona de variables locales
codigo del programa..............
} fin del programa
Desarrollo del código de las funciones
función(1)
{
}
……….
función(n)
{
}
FUNCIONES DEFINIDAS POR EL USUARIO

Un programa en lenguaje C es una colección de funciones, algunas funciones
predefinidas denominadas funciones de biblioteca y otras definidas por el usuario. Se
invocan por su nombre y los parámetros opcionales que tenga. Después que la función
sea llamada, el código asociado con la función se ejecuta y a continuación, se retorna a la
función llamadora. En lenguaje C, las funciones definidas por el usuario requieren una
declaración o prototipo en el programa, que indica al compilador el nombre por el cual
será invocada. Las funciones de biblioteca requieren que se incluya el archivo de acuerdo
a la función que le pertenezca.
Su formato es:
Tipo de retorno nombre de la función (tipo de dato arg1,...,tipo de dato argn);
Estructura de una funcion

#include<archivo.h>
...............
Tipo de regreso nombre de la función(tipo de dato arg1,....,tipo de dato argn);
main()
{
Declaraciones;
secuencia de sentencias
nombre de la función(arg1, arg2,....,argn); /*Llamada de la función */
}
/*Definición de la función */
tipo de retorno nombre de la función(tipo de dato arg1,....,tipo de dato argn)
{
declaraciones
instrucciones
return 0; /*Cuando la función no regresa valores*/
return (expresión); /*Cuando la función regresa valor*/
} /*Fin de la función creada por el usuario*/
/* Programa de aplicación de las funciones definidas por el usuario*/
#include <stdio.h>
int cuadrado(int); /*Prototipo de la función*/
main()
{
int x;
for(x=1;x<=20;x++)
printf(“%d”,cuadrado(x)); /*Llamada de la función*/
printf(“\n”);
return 0;
}
int cuadrado(int y) /*Definición de función */
{
return y*y;
}
/* Programa que calcula potencias de base real positiva y exponente entero*/

#include <stdio.h>
float potencia (float, int); //Prototipo de la funcion
main ( )
{
int exponente;
float base;
printf ("Introducir base y exponente: ");
scanf ("%f%d", &base, &exponente);
if ( base <= 0 )
printf ("Solo admito bases positivas \n");
else { if ( exponente > 0 )
printf ("Potencia: %f \n", potencia(base, exponente));
else
printf ("Potencia: %.2f \n",1.0/potencia(base, -exponente));
}
}
float potencia (float b, int e)
{
if ( b == 1 ) return (1);
else {
if ( e == 1 ) return ( b );
else {
int i; float p=1;
for ( i=1; i<=e; i++ ) p=p*b;
return ( p );
}
}
}
.
/*programa que visuliza el número mayor aplicando funciones*/

#include<stdio.h>
int maximo(int a,int b,int c ); //Prototipo de la funcion
main()
{
int a,b,c,d;
printf("\n Introducir tres valores:\n");
scanf("%d%d%d",&a,&b,&c);
d = maximo(a,b,c); /* Llamada de la función */
printf("El maximo valor es: %d",d);
return 0;
}
int maximo(int x,int y,int z) //Definición de la función
{
int mayor;
if((x>y)&&(x>z)) mayor =x;
if((y>x)&&(y>z)) mayor =y;
if((z>x)&&(z>y)) mayor =z;
return mayor;
}
/*programa para calcular el factorial de un entero n */

#include<stdio.h>
int factn( int n);
main()
{
int n,factorial;
printf("Introduce un nunero entero:");
scanf("%d",&n);
printf("El factorial de %d es: %d",n,factn(n));
}
int factn(int numero)
{
int i;
int producto = 1;
if(numero>1)
for(i=2;i<=numero;++i)
producto*=i;
return producto;
}
.
CONCEPTOS BÁSICOS DE C

CÓDIGO FUENTE. Es el texto que el usuario escribe, basándose en el conjunto de
instrucciones y en la sintaxis que el lenguaje dicte (.c o .ccp).
CÓDIGO OBJETO. Es la traducción del código fuente de un programa a código máquina,
que es el que la computadora puede interpretar y ejecutar directamente. Este código es la
entrada al enlazador (.obj).
ENLAZADOR. Se encarga de combinar las funciones de la biblioteca estándar de C con
el código que se ha escrito. La salida del enlazador es un programa ejecutable (.exe).
BIBLIOTECA. Son archivos que contienen las funciones estándar que se pueden usar en
los programas. Estas funciones incluyen todas las operaciones de E/S, así como otras
rutinas útiles.
COMPILACIÓN. Es el proceso durante el cual se traducen una a una las sentencias del
código fuente a código máquina, en esta acción pueden ocurrir errores de sintaxis.
EJECUCIÓN. Es el proceso que permite que veamos al programa funcionar, llevando a

cabo las operaciones que se han implementado.
FUNCIÓN. Una función en C es un grupo de instrucciones que realizan una o más

acciones.
.
PASOS PARA LA EJECUCIÓN DE UN PROGRAMA EN C

Inicio
Edición
(código fuente)
Compilación
(del código
fuente)
NO
SI
Erro
r
NO
Enlazador
NO
SI
Erro
NO
r
Ejecución
SI NO
Erro
r
NO
Final
CARACTERISTICAS DE UN PROGRAMA EN LENGUAJE C
1.- Integridad. Corrección de los cálculos en un programa.

2.- Claridad. Esto permite a otro programador seguir la lógica del programa sin mucho
esfuerzo.
3.- Sencillez. Redactar programas claros y sencillos para su fácil corrección.
4.- Eficiencia. Esto se relaciona con la velocidad de ejecución y utilización eficiente de la
memoria.
5.- Modularidad. Los programas se pueden dividir en pequeñas subtareas o módulos. El
diseño modular de los programas aumenta la claridad y corrección de estos y facilita
posibles cambios futuros.
6.- Generalidad. Un programa debe ser lo más general posible. Por ejemplo, se puede
hacer un programa que lea los valores de ciertos parámetros en lugar de dejarlos fijos.
EJEMPLOS DE PROGRAMAS EN C

#include<stdio.h>
/* Programa inicial de C */
main()
{
printf(“Mi primer programa en C\n”);
printf(“Bievenido al mundo maravilloso de C.......\n”);
printf(“Que interesante\n”);
return 0;
}
#include<stdio.h>
/*Presentación de un trabajo*/
main()
{
printf(“Nombre del alumno:-----------------------------\n”);
printf(“No. de control: ------------------------------------\n”);
printf(“Escuela:----------------------------------------------\n”);
printf(“Carrera:-----------------------------------------------\n”);
printf(“Materia:-----------------------------------------------\n”);
printf(“Hora:---------------------------------------------------\n”);
printf(“Maestro:----------------------------------------------\n”);
printf(“Lugar y fecha:--------------------------------------\n”);
return 0;
}
//Programa que calcula la media de tres notas

#include<stdio.h>
#include<conio.h>
main()
{
clrscr();
char nombre [20];
float nota1,nota2,nota3,media;
printf("Por favor, introduce tu nombre:");
scanf("%[^\n]", nombre);
printf("Por favor ,introduce la primera nota:");
scanf("%f",&nota1);
printf("Por favor, introduce la segunda nota:");
scanf("%f",&nota2);
printf("Por favor, introduce la tercera nota:");
scanf("%f",&nota3);
media= (nota1+nota2+nota3)/3;
printf("n\nNombre:%-s\n\n", nombre);
printf("Nota 1:%-5.1f\n",nota1);
printf("Nota 2:%-5.1f\n",nota2);
printf("Nota 3:%-5.1f\n\n",nota3);
printf("Media:%-5.1f\n\n",media);
getch();
}
.
//Programa que calcula una suma de dos variables y su raíz cuadrada

#include <stdio.h>
#include <math.h>
#include <conio.h>
main() // Función de cabecera principal
{
//clrscr(); //Limpiar pantalla
float i=2.0 , j=3.0; //Declaración de variables
printf("i = %f\nj = %f\nSuma(i+j) = %f\nRaiz(i+j) = %f" ,i,j,i+j, sqrt(i+j)); //Instrucc. de salida
getch(); //Amarrar pantalla
}
ELEMENTOS BÁSICOS DE C
Lenguaje c se auxilia de ciertos elementos básicos para la construcción de programas
como: el conjunto de caracteres, secuencias de escape, identificadores, palabras clave,
tipos de datos, constantes, arreglos, declaraciones, expresiones, sentencias y
operadores.
CONJUNTO DE CARACTERES DE C
En la elaboración de programas en C se pueden utilizar para formar los elementos
básicos (constantes, variables, operadores, expresiones) las letras mayúsculas de la A a
la Z, las minúsculas de la a a la z , los dígitos del 0 al 9 y ciertos caracteres especiales.
Lista de caracteres especiales.
! * / % + - \ < > = & | ^ # ( ) { } [ ] ~ , ; " _ : ' ? . (blanco)
La mayoría de las versiones del lenguaje también permiten que otros caracteres, como @
y $, se incluyan en comentarios y cadenas de caracteres por medio de las funciones de
biblioteca printf() y puts().
Ejemplos: Printf(“@”); Puts(“@”); o Printf(“$”); Puts(“$”);
SECUENCIAS DE ESCAPE
En C también se utilizan combinaciones de caracteres no imprimibles como: el retroceso
de un espacio \b, un salto de línea \n, un tabulador \t, un sonido bell \a, etc. solo se utilizan
en las cadenas de caracteres de las funciones de biblioteca printf() y Puts(),
Ejemplos:
printf(“Hola\namigos\ncomo van los estudios en C.”);
\n indica al compilador que el texto escrito se visualice en pantalla de la siguiente forma:
Hola
amigos
como van los estudios en C.
printf(“\tBuenas tardes.”);
\t indica al compilador que el texto escrito se visualice en pantalla de la siguiente forma:
Buenas tardes.
Una secuencia de escape siempre representa un solo carácter, aún cuando se escriba
con dos o más caracteres.
Ejemplos:
‘\102’ secuencia de escape en octal que representa el número decimal 66 y la letra B en el
código ASCII.
‘\x45’ secuencia de escape en hexadecimal que representa el número decimal 69 y la letra
E en el código ASCII.

TABLA DE LAS PRINCIPALES SECUENCIAS DE ESCAPE
CODIGO SIGNIFICADO VALOR ASCII (decimal) VALOR ASCII (hexadecimal)

‘\a’ sonido bell 07 0x07
‘\n’ nueva línea 10 0x0A
‘\r’ retorno de carro 13 0x0D
‘\f’ nueva página 12 0x0C
‘\t’ tabulador horizontal 09 0x09
‘\b’ retroceso (backspace) 08 0x08
‘\’’ comilla simple 39 0x27
‘\’’’ comillas 34 0x22
‘\\’ barra invertida (backslash) 92 0x5C
‘\?’ interrogación 63 0x3F
‘\0’ carácter nulo 00 0x00
‘\ooo’ cualquier carácter (donde ooo es el código ASCII expresado en octal )
‘\xhh’ cualquier carácter (donde xhh es el código ASCII expresado en hexadecimal )
IDENTIFICADORES
Los identificadores son nombres que se les da a varios elementos de un programa, como
variables, constantes, funciones Y arreglos. Un identificador está formado por letras y
dígitos, en cualquier orden, excepto el primer carácter, que debe ser una letra o un
carácter de subrayado.
Se pueden utilizar mayúsculas y minúsculas (no acentuadas), aunque no se pueden
intercambiar, esto es, una letra mayúscula no es equivalente a su correspondiente
minúscula de acuerdo al código ASCII.
El carácter de subrayado se utiliza frecuentemente para unir varias palabras y así formar
un identificador.
Ejemplos:
El_area_del_triangulo_es El_porcentaje_es
La longitud de los identificadores no se limita, aunque el compilador sólo reconoce los 31
primeros caracteres. Los demás caracteres son utilizados para la comodidad del
programador, esto depende del compilador que se utilice.
Ejemplos de cómo deben escribirse los identificadores:
correcto: Incorrecto:
q 6q Carácter ilegal (el número al inicio)
Area A-rea Carácter ilegal (-)
El_cubo _es_igual_a El-cubo-es_igual_a Carácter ilegal (´)

PALABRAS CLAVE
En lenguaje C se usan ciertas palabras predefinidas llamadas palabras clave que se
utilizan con un propósito ya establecido; No se pueden utilizar como identificadores
definidos por el programador a menos que se escriban con letras mayúsculas.
En C está estrictamente prohibido escribir las palabras clave y las funciones de biblioteca
en mayúsculas, todo se escribe en minúsculas
PALABRAS CLAVE USADAS EN C
auto double int struct

break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
TIPOS DE DATOS
En lenguaje C se usan cinco tipos de datos: char (carácter), int (entero), float (coma
flotante), double (coma flotante de doble precisión) y void (sin valor).
Los datos de tipo char se usan para guardar valores definidos en juego de caracteres
ASCII, así como cualquier cantidad de 8 bits. Las variables de tipo int se usan para
guardar cantidades numéricas enteras.
Las variables de tipo float y double se usan para guardar números reales. (Los números
reales son aquellos que tienen una parte entera y una fraccionaria). Mientras que el tipo
void tiene tres usos: el primero es para declarar explícitamente una función como que no
devuelve valor alguno, el segundo es para declarar explícitamente una función sin
parámetros, y el tercero es para crear punteros genéricos.
El tipo de dato double maneja más cifras significativas y mayor valor posible del
exponente.
TABLA DE LOS TIPOS DE DATOS BÁSICOS
Espec. de
Tipo de dato Tamaño Rango formato
char 8 bits -128 a 127 %c ó %d
unsigned char 8 bits 0 a 255 %c ó %d
Short int 16 bits -32,768 a 32,767 %hd
int 32 bits -2,147,483,648 a 2,147,483,647 %i ó %d
unsigned int 32 bits 0 a 4,294,967,295 %u
float 32 bits 3.4x10e-38 a 3.4x10e38 %f ó %g ó %e
double 64 bits 1.1x10e-308 a 1.7x10e308 %lf
bool 8 bits 0a1
Para la definición de variables se debe poner primero el tipo de dato a definir y luego el
nombre de la variable, (si se desea inicializarla se le puede asignar un valor. Ejemplo:

variable = valor) y, si se requiere definir mas de una variable del mismo tipo, se va
poniendo una coma a continuación y al final termina en punto y coma (;). Ejemplos: float x,
y, z; o float x = 12.32500, y = 0.012519, z;
//programa de ejemplo
/* Uso del operador sizeof para determinar el tamaño de
una variable */
#include <stdio.h>
main () {
char c;
int n, d;
n= sizeof(c);
printf(" el número de bytes de la variable c es %d", n);
n= sizeof(d);
printf(" el número de bytes de la variable d es %d", n);
n= sizeof(int);
printf(" el número de bytes que ocupa el tipo entero es %d", n);
printf(" el número de bytes que ocupa el tipo double es %d",
sizeof(double));
return 0;
}
#include <stdio.h>
#define va_int 805
#define va_float 332.41e-1
main () {
printf(" %f ", va_float); /* imprime 33.241*/
printf(" %.1f ", va_float); /* imprime 33.2*/
printf(" %.4f ", va_float); /* imprime 33.2410*/
printf(" %1.4e ", va_float); /* imprime 3.3241e+01*/
printf(" %d ", va_int); /* imprime 805*/
printf(" %10f", va_float); /* imprime 33.241*/
return 0;
}
CONSTANTES
En C se usan cuatro tipos básicos de constantes: constantes enteras, constantes de coma
flotante, constantes de carácter y constantes de cadena de caracteres (también se utilizan
las constantes enumeradas que se tratarán en capítulos avanzados).
Las constantes son datos referenciados a través de un identificador, cuyo valor no varía a
lo largo de toda la ejecución de un programa.
CONSTANTES ENTERAS
Una constante entera, es un número con un valor entero que se puede escribir en tres
sistemas numéricos: decimal, octal o hexadecimal.
Las constantes enteras y de coma flotante representan números. Por tal motivo se les
denomina de tipo numérico.
Reglas para el uso de constantes.
1.- No se pueden incluir comas ni espacios en blanco en las constantes.
2.- Una constante puede ir precedida del signo menos (-).

3.- El valor de una constante no puede exceder un límite máximo y un mínimo
especificados. Para cada tipo de constante, estos límites varían de un compilador de C a
otro.
Una constante ENTERA DECIMAL puede estar formada por cualquier combinación de
dígitos del 0 al 9. Si la constante tiene dos o más dígitos, el primero de ellos debe ser
distinto de 0. Ejemplos de la escritura de las constantes decimales:
Correcta: 0 1 2 9 10 963 9999 5865 12548
Incorrecta: 15,45 carácter ilegal (,) 45 56 carácter ilegal (blancos),
0568 el primer dígito no puede ser cero.563+965 carácter ilegal (+)
Una constante ENTERA OCTAL puede estar formada por cualquier combinación de
dígitos del 0 al 7. Al escribir una cantidad entera octal el primer dígito debe ser un 0, con
el fin de identificar el sistema numérico octal.
Ejemplos de la escritura de las constantes Octales:
Correcta: 0 01 0457 0632 07777 012453 02456 014570
Incorrecta: 756 no comienza con cero, 03287 ilegal (8), 052.236 ilegal (.)
Una constante entera HEXADECIMAL debe comenzar por 0x o 0X. Después puede
aparecer cualquier combinación de dígitos del 0 al 9 y letras de la A la F mayúsculas o
minúsculas.
El valor máximo de una constante entera (int) varía de una computadora a otra pero en la
mayoría es 32767.
Ejemplos de la escritura de las constantes hexadecimales:
Correcta: 0x4589 0x54ebc 0xabf5e 0XDEF 0X85BCd2 0XFDEA
Incorrecta: 0x5.12e carácter ilegal (.), 0FA56 carácter ilegal 0, debe ser 0X
CONSTANTES DE COMA FLOTANTE

Una constante de coma flotante es un número en base 10 que contiene un punto decimal
y/o un exponente.
Ejemplos de la escritura de las constantes de coma flotante:
Correcta: 0. 5 3e-9 86230. 0.5235 145.236 1248E-5
Incorrecta: 256-5 carácter ilegal (-), 5,3625 carácter ilegal (,), 5e+5.6 el exponente debe
ser una cantidad entera.
En C la letra E se sustituye por la base 10, por ejemplo 15.6x10 -6 en C se debería escribir
15.6E- 6 o 15.6e- 6.
La precisión de las constantes de coma flotante (el número de cifras significativas) puede
variar de un compilador a otro.
Las constantes enteras son cantidades exactas. Mientras que las constantes de coma
flotante son aproximaciones. Por esta razón no se pueden utilizar los valores de coma
flotante para ciertas funciones como indexaciones o conteo (no pueden ser índices ni
contadores), en las que son necesarios valores exactos.
El overflow (desbordamiento) es lo que se produce cuando intentamos almacenar en una
variable un número mayor del máximo permitido. El comportamiento es
distinto para variables de números enteros y para variables de números en
coma flotante.
Ejemplo:
El resultado marcará error
#include<stdio.h>
porque el tipo de dato no es el
main()
adecuado debido a que el rango es
{
menor al resultado. En este caso
int a 2000, b = 500, c;
se recomienda el tipo de dato long
c = a*b;
int.
printf(“El resultado de c es: %d\n”,c);

}
CONSTANTES DE CARÁCTER
Es un solo carácter encerrado entre comillas simples.
Ejemplos:
Declaración de Caracteres Valor numérico ASCII
char c = ‘#’; 035
char c = ‘\’;
092
Ejemplos de programas
//Programa de aplicacion del código ASCII

#include<stdio.h>
main( )
{
char num=’@’;
printf("El caracter %c en ASCII representa el numero %d",num,num);
}

#include<stdio.h>
main( )
{
char num=64;
printf("El numero %d em ASCII representa al caracter %c",num,num);
}
De otro modo
#include<stdio.h>
main( )
{
char num;
printf("Ingrese el numero enterro: ");
scanf(“%d”,&num);
printf("El numero %d em ASCII representa al caracter %c",num,num);
}
//Programa que detecta si una letra es minuuscula o mayuscula

#include<stdio.h>
main( )
{
char c;
c=getchar( );
if ( ( c>=65 ) && ( c<=90 ) )
printf("Es letra mayuscula\n");
else {
if ( (c>=97) && (c<=122) )
printf("Es letra minuscula\n");
else
printf("No es un caracter alfabetico\n");
}

}
CONSTANTES DE CADENA DE CARACTERES
ES de cualquier número de caracteres consecutivos o ninguno encerrados entre comillas
(“ “).
Ejemplos:
Printf(“Buenas tardes\n”); o puts(“Buenas tardes”); printf(“ “)¸ Espacio en blanco.
Las cadenas de caracteres se usan generalmente en las funciones de printf(“ “), puts(“ “) y
en las declaraciones de arreglos de cadenas de caracteres .
Ejemplos:
printf(“Hola...”); en pantalla se visualizará: Hola...
puts(“Calle 10 no. 50”); en pantalla aparece: Calle 10 no. 50.
Se debe tener en cuenta que una constante de carácter (‘c’) no es equivalente a una
constante de cadena de caracteres (“c”). Ya que una constante de carácter tiene un valor
entero correspondiente, mientras que la constante de cadena no tiene valor entero
equivalente.
VARIABLES
Una variable es un identificador que se utiliza para representar cierto tipo de información
dentro del programa. En algún punto del programa se le asigna a la variable un valor que
después se puede recuperar en cualquier momento sin más que hacer referencia la
nombre de la variable.
Una variable contendrá un dato simple como una cantidad numérica o una constante de
carácter. A una variable se le pueden asignar diferentes valores en distintas partes del
programa, de tal manera la variable pude cambiar durante la ejecución del programa. Sin
embargo el tipo de datos asociado a la variable no puede cambiar.
Ejemplos:
p = ’g’; a la variable p se asigna el carácter g
x = 30; a la variable x se asigna el valor numérico 30
F = m*a; a la variable F se asigna el producto de las variables m*a
E = m*v*v/2; a la variable E se asigna el producto de las variables m*v*v/2
ARRREGLOS (ARRAYS)
Un arreglo es un identificador que representa una colección de datos. Cada dato es
representado por su elemento del arreglo correspondiente, de esta forma el primer dato
es representado por el primer elemento del arreglo y así sucesivamente. Los elementos
del arreglo se distinguen unos de otros por el valor que se le asigna al índice.
Ejemplo:
sea la variable y un arreglo de 5 elementos. El primer elemento es y[0], el segundo y[1], y
así sucesivamente. El último elemento será y[4]. Por consecuencia para un arreglo de n
elementos los valores del índice se encontrarán siempre entre 0 y n-1.
Arreglo de tipo carácter unidimensional. Este arreglo se utiliza generalmente para

representar una cadena de caracteres, donde cada elemento de arreglo representa un
carácter de la cadena. Este arreglo tendrá un solo índice cuyo valor determina los
elementos individuales del arreglo.
Si el arreglo contiene n elementos, el índice será una cantidad entera en que los valores
se encuentren entre 0 y n-1. Una cadena de caracteres requerirá de n+1 elementos,
debido al carácter nulo (\0) que se añade automáticamente al final de una cadena.
Ejemplo:

Se desea almacenar una cadena de caracteres TAMPICO en un arreglo de caracteres
unidimensional llamado cadena. TAMPICO contiene7 caracteres, cadena será un arreglo
de 8 elementos debido al carácter nulo (\0).
char cadena[8];
No.de elem. Valor del indice Elemento del arreglo Carácter
1 0 cadena[0] T
2 1 cadena[1] A
3 2 cadena[2] M
4 3 cadena[3] P
5 4 cadena[4] I
6 5 cadena[5] C
7 6 cadena[6] O
8 7 cadena[7] \0
Representación esquemática
T A M P I C O \0
0 1 2 3 4 5 6 7 Valor del índice
Nota: si la cadena es de n elementos de le debe agregar un elemento mas debido al
carácter nulo, en caso contrario la cadena se truncaría faltándole una letra.
Ejemplo:
char cadena[7];
T A M P I C \0
0 1 2 3 4 5 6 Valor del índice
Para declarar un arreglo (array), cada variable del arreglo debe ser seguida de un par de
corchetes, con un entero positivo dentro de estos que especifica el tamaño o el número de
elementos del arreglo. Ejemplo: char linea[50]; Un arreglo de tipo carácter también se
puede inicializar en una declaración. Para realizar esta operación el arreglo se escribe con
los corchetes vacíos sin especificar el tamaño, solo se le asigna la cadena de caracteres
encerrada entre comillas, finalizando en punto y coma.
.
Ejemplo:
char texto[] = “México”;//Arreglo unidimensional con asignación
Existen diferentes tipos de arreglos de enteros de caracteres, unidimensionales y
multidimensionales.
Sus formatos son:

Tipo de dato nombre[expresión]; //Unidimensional vectores
Tipo de dato nombre[exp1] [exp2]....... [expn]; //Multidimensionales tablas
Ejemplos de declaraciones:
int dígitos[10] = {1,2,3,4,5,6,7,8,9};
float x[5] = {0,0.12,0,-0.32,0};
char color[3] = { ‘R’,’E’,’D’};
int a[50]; //Arreglo unidimensional
float x[5][6]; //Arreglo bidimensional
float x[5][6][2][3].. ]; //Arreglo multidimensional

Ejemplos:
/* programa que visualiza el alfabeto aplicando arreglos*/
#include <stdio.h>
main()
{
char alfabeto[27]; // 26 letras más NULL
char letra;
int i;
for (letra='A', i = 0; letra <='Z'; letra++, i++)
alfabeto[i] = letra;
alfabeto[i] = NULL;
printf("Las letras son: %s",alfabeto);
}
//Programa que almacena numeros enteros en un arreglo para despues ordenarlos.

#include<stdio.h>
#include<conio.h>
main()
{
int x[10],i,j,a;
for (i=0; i <10; ++i) /* Captura de los valores del arreglo */
{
printf("De valor de x[%d]:", i+1);
scanf("%d",&x[i]);
} // Ordenar el arreglo
for (i=0; i <10; ++i)
for (j=0; j <10; ++j)
if ( x[i] < x[j] )
{
a= x[i];
x[i]=x[j];
x[j]=a;
} //contenido del archivo
for(i=0; i <10; ++i)
printf("%3d", x[i]);
}
/*Aplicación de arreglos unidimensionales*/

#include <stdio.h>
main()//Programa que cuenta de 0 99
{
int i,A[100];
for (i = 0; i< 100; i++){
A[i] = i;
printf("[%d]\t",A[i]);
}
}

/*Programa que ejecuta la tabla del cinco*/
#include <stdio.h>
main()
{
char titulo[] = "Esta es la tabla del 5";
int espacios[10];
int indice;
for(indice=0; indice < 10; indice++)

espacios[indice] = 5*(indice+1);
printf("%s\n\n", titulo);
for(indice=0; indice < 10; indice++)
printf("5 x %2d = %4d\n", (indice+1), espacios[indice]);
return 0;
}
/* Programa que determina el no. de caracteres de un arreglo */

#include<stdio.h>
main()
{
char texto[ ] = “Abecedarios”;
printf(“Numero de caracteres: %d caracteres.\n”, sizeof (texto));
return 0;
}
// Programas de ejemplo
/*Calcular la media de n números, después computar la desviación de cada número
respecto a la media*/
#include<stdio.h>
int n=5;
float lista[] = {3, -2, 12, 4.4, 3.5};
main()
{
int cont;
float media, d, suma = 0;
/*Calcular la media y escribir la respuesta */
for(cont = 0; cont<n; ++cont)
suma+=lista[cont];
media = suma/n;
printf("\nLa media es %5.2f\n\n",media);
/*Calcular y escribir las desviaciones respecto a la media */
for(cont = 0; cont < n; ++cont) {
d = lista[cont] - media;
printf("i=%d x=%5.2f d=%5.2f\n",cont+1,lista[cont],d);
}
}

/*Como inicializar arreglos multidimensionales*/
#include <stdio.h>
void imprimir_arreglo(int[][3]);
main()
{
int arreglo1[2][3]={{1,2,3},{4,5,6}};
int arreglo2[2][3]={1,2,3,4,5};
int arreglo3[2][3]={{1,2},{4}};
printf("el arreglo1 es:\n");
imprimir_arreglo(arreglo1);
printf ("el arreglo1 es:\n");
imprimir_arreglo (arreglo2);
return 0;
}
void imprimir_arreglo(int a[][3])
{
int i,j;
for(i=0;i<=1;i++){
for(j=0;j<=2;j++)
printf("%d", a[i][j]);
printf("\n");
}
}
EXPRESIONES
Una expresión representa una unidad de datos simple, tal como un número o un carácter,
una constante, una variable, un elemento de un arreglo o una referencia de una función.
También puede consistir en una combinación de tales identidades mediante operadores.
Las expresiones también pueden representar condiciones lógicas que son ciertas o falsas.
Las condiciones cierto y falso se representan por los valores enteros 1 y 0,
respectivamente. Por lo tanto las expresiones lógicas representan cantidades numéricas.
Ejemplos:
E = m*v*v/2;
x<=y; p = = q;
a>b&&c<d||p<q; x*=y;
SENTENCIAS
Una sentencia hace que la computadora ejecute una acción. En C se utilizan tres tipos
diferentes de sentencias: sentencias de expresión o de asignación, sentencias
compuestas y de control.
SENTENCIAS DE EXPRESIÓN O DE ASIGNACIÓN

Una sentencia de expresión consiste en una expresión seguida de un punto y coma (;). La
ejecución de una sentencia de expresión hace que se evalúe expresión.
Ejemplos:
x =5; El valor numérico 5 es asignado a la variable x
p = q/r; A p se le asigna el resultado de las variables q y r
++k; Hace que la variable k se incremente en 1
.

SENTENCIAS COMPUESTAS
Una sentencia compuesta esta formada por varias sentencias individuales encerradas en
un par de llaves ({y}). Las sentencias individuales pueden ser a su vez sentencias de
expresión, sentencias compuestas o sentencias de control.
Una sentencia compuesta hace posible incluir sentencias dentro de otras sentencias. A
diferencia de las sentencias de expresión estas no terminan en punto y coma (;).
Ejemplos:
#include<stdio.h>
/*Programa que calcula el producto de dos números */
main( )
{ /* Inicia sentencia compuesta */
Instrucciones……..
} /*Termina sentencia compuesta */
SENTENCIAS DE CONTROL
Las sentencias de control se usan para conseguir ciertas acciones especiales en un
programa, como comprobaciones lógicas, bucles y ramificaciones. En algunos casos las
sentencias de control requieren que otras sentencias se encuentren incluidas en ellas.
Ejemplos:
#include<stdio.h>
main()
{
int contador;
for (contador = 1; contador<=500; ++contador){
printf("%d\t”, contador);printf(“Hola…..”);
}
return 0;
}
#include<stdio.h>
main()
{
int contador=1;
while (contador<=500){
printf("%d\t”, contador);
++contador;
}
return 0;
}
#include<stdio.h>
main()
{
int contador=1;
do
{
printf("%d\t”, contador);
++contador;
} while (contador<=500);
return 0;
}

CAPITULO 3
OPERADORES Y EXPRESIONES
Los operadores son símbolos que representan operaciones y, se utilizan para formar
expresiones. Lenguaje C, posee un gran número de operadores que se pueden agrupar
en varias categorías como: operadores aritméticos, operadores monarios, operadores
relacionales, operadores lógicos, operadores de asignación y el operador condicional. Los
datos sobre los que actúan los operadores se llaman operandos. A algunos operadores se
les llama binarios porque requieren dos operandos para ejecutarse, a otros se les llama
monarios o unarios ya que actúan sobre un solo operando, también existe un operador
que actúa sobre tres operandos a este se llama operador condicional.
Un operador sirve para manipular datos.
OPERADORES ARITMÉTICOS
Los operadores aritméticos son aquellos que sirven para realizar operaciones tales como
suma, resta, multiplicación, división y el resto de una división (operador módulo).
Los operandos sobre los que actúan los operadores aritméticos deben representar valores
numéricos. De este modo, los operandos deben ser cantidades enteras, de coma flotante
o caracteres.
En lenguaje C no hay operador de exponenciación. Sin embargo, se utiliza la función de
biblioteca pow que realiza la exponenciación. Esta función pertenece al archivo de
biblioteca #include<math.h>. Ejemplo: pow(x,y) x = base y = exponente pow(x,y)=x y
2
por ejemplo: pow(3,2)=3 =9.
TABLA DE LOS OPERADORES ARITMÉTICOS
OperadorExpresió Significado
n
+ a+b Suma
- a-b Diferencia (o cambio de signo)
* a*b Producto
/ a/b División entera
% a%b Módulo (resto de la división entera)
/* Programa ejemplo de los operadores aritméticos */

#include <stdio.h>
main()
{
int a = 10,b = 3,c,d,e,f,g; float x =5,y = 3, potencia;
c = a+b; //Suma
d = a-b; //Resta
e = a*b; //Multiplicación
f = a/b; //División
g = a%b; //Residuo de una division o módulo
potencia = pow(x,y);
printf ( " %d + %d = %d\n",a,b, c);
printf ( " %d - %d = %d\n",a,b, d);
printf ( " %d * %d = %d\n",a,b, e);
printf ( " %d / %d = %d\n",a,b, f);
printf ( " El residuo de la división es:= %d\n",g);
printf ( " 5 elevado a la 3 es igual a: %.2f”,potencia);//Aplicación de la función pow
}
.
OPERADOR RESTO (%)
Con este operador se puede obtener el residuo de una división. Este operador funciona
únicamente con números enteros, no vale para números float o double.
Ejemplos:
#include <stdio.h>
main()
{
int a = 100,b = 60,c;
c = a%b; //Residuo de una division o módulo
printf ( " El residuo de la división es: %d\n", a, b, c);
return 0;
} //Salida: El residuo de la división es 40
/* Aplicación del operador resto */
//programa que visualiza números pares
#include <stdio.h>
main()
{
int a;
for(a = 0; a<=100; ++a){
if(a%2==0)//isualizar numerous pares
printf( "a = %d \t", a);
}
return 0;
}
PRECEDENCIA DE LOS OPERADORES ARITMÉTICOS (ORDEN DE EVALUACIÓN)

Los operadores de mayor precedencia se realizan antes que los operadores que tienen
menor precedencia. Sin embargo se puede alterar el orden natural mediante el uso de
paréntesis.
Los operadores, *, / y % se encuentran dentro de un mismo grupo de precedencia, y + y –
se encuentran en otro. El primer grupo tiene mayor precedencia que el segundo. Por lo
tanto las operaciones de *, / y % se realizarán antes que las de adición y sustracción.
La asociatividad de los operadores aritméticos es de izquierda a derecha. Por
consecuencia las operaciones consecutivas de los operadores aritméticos se realizan de
izquierda a derecha.
Ejemplo:
30 / 2 + 13
De acuerdo al orden de precedencia el signo / tiene un orden superior al signo +,
por lo tanto primero se hace la división 30/2=15 y luego la suma 15+13=28.
Otro ejemplo: 30 / ( 2 + 13 )
Ahora con el paréntesis cambia el orden de evaluación. El que tiene mayor precedencia
ahora es el paréntesis, se ejecuta primero. Como dentro del paréntesis sólo hay una suma
se evalúa sin más, 2+13=15. Ya solo queda la división 30/15=2. Otro caso: 40*( 3*2 +6 )
El paréntesis es el que tiene mayor precedencia y es, el se evalúa primero. Dentro del
paréntesis tenemos producto y suma. Se evalúa primero el producto, 3*2=6. Después la
suma 6+6=12. Y al final el resultado será: 40*12=480.

.
Ejemplos:
Dada la declaración entera, calcule la siguiente expresión:
int i = 10, j = 7, k = 6, c;
c = 2*((i%j)*(6+(j-5)/(k+2))) c = 2*((10%7)*(6+(7-5)/(6+2)))
c = 2*((3)*(6+(2)/(8))) c = 2*((3)*(6+0)) c = 2*((3)*(6)) c = 2*(18) c = 36
float a = 1, b = 2, c = 3, d = 4, E, F;
E = a - b/ c * d; E =1-2/3*4 = 1-.666666*4 = 1 - 2.666666 E = -1.666666
F = (a - b)/(c*d) F = (1-2)/(3*4) =(-1)/(12) F = - 0.08333333
¿Que pasa cuando los operandos difieren en el tipo de datos?

Estos pueden sufrir una conversión de tipo antes de que la expresión alcance su valor
final, el resultado final se expresará con la mayor precisión posible.
Reglas para su utilización
1.- Si los dos operandos son de precisión distinta (por ejemplo un float y un double) el
resultado será el de mayor precisión, en este caso el double.
2.- Si un operando es de tipo float , double o long double y el otro de tipo int o
char(incluyendo short int y long int), el char y el int se convertirán al tipo float, double o lon
double según el caso.
3.- Si un operando es del tipo long int y el otro en int, el resultado será de tipo long int.
4.- Una operación entre un short y un int tendrá como resultado un tipo int.
Ejemplo:
int f = 10;
float q = 5.612345; f+q = 15.612345; El resultado se dará en coma flotante (float)
Si se desea, se puede convertir el valor de una expresión a un tipo de datos diferente.
Para realizar esto, la expresión debe de ir precedida por el nombre del tipo de datos
deseado, encerrado entre paréntesis.
formato: (tipo de datos) expresión;
Ejemplos:
int d, p; float f,t; p = (d+f); t = (d+f); p = ((int (d+f))/8;
p = ((int (d+f))/8; t = ((float(d+f))/8;
Esto depende del tipo de dato que se quiera visualizar en pantalla, no tiene nada
que ver con las reglas anteriores.
OPERADORES MONARIOS O UNARIOS

En se C se incluyen ciertos operadores que actúan sobre un solo operando para producir
un nuevo valor.
A estos operadores se les denomina operadores monarios. Se les llama así porque suelen
preceder a su único operando, aunque algunos se escriben detrás de operando. Los
operadores monarios se clasifican en: operador menos monario (-), operador de
incremento (++), operador de decremento (--) y el operador sizeof (tamaño de).
OPERADOR MENOS MONARIO (-)

Este se utiliza cuando un signo menos precede a una constante numérica, una variable o
una expresión.
Una operación menos monaria siempre será distinta del operador aritmético
sustracción(-), debido a que este operador es binario.
Ejemplos:
-568 -(x+y) -5/(a-b) -(a*b-c/d) -01478 -0xafd6 -7E-6 -.0568

.
OPERADORES DE INCREMENTO (++) Y DECREMENTO (--)
Estos operadores se usan más frecuentemente en las sentencias de control de flujo para
realizar iteraciones.
El operador de incremento (++), hace que su operando se incremente en uno. Mientras
que el operador de decremento (--) hace que su operando se decremente en uno. El
operando utilizado siempre debe ser una variable.
TABLA DE EQUIVALENCIAS DE LOS OPERADORES MONARIOS ++ Y –
Operador Expresión Expresión equivalente

++ ++Variable Variable = variable +1
-- --Variable Variable = variable –1
Ejemplos:
int i = 5 ++i Equivale a i = i+1 por lo tanto i = 6. Este operador equivale a sumar 1 a la
variable. En caso contrario se resta 1 a la variable int i = 5 –i equivale a i = i-5 por lo
tanto i = 4.
/* Aplicación del operador (++) en un programa */

#include <stdio.h>
main()
{
int a, b, c;
a = 5;
b = ++a;
c = ( a + 5 * 2 ) * ( b + 6 / 2 ) + ( a * 2 );
printf( "%d, %d, %d", a, b, c );
return 0;
} /*Salida en pantalla: 6, 6, 156. En la primera a vale 5. Pero en la segunda se
ejecuta b = ++a = ++5 = 5+1 por lo tanto a = 6*/
/* Aplicación del operador (--) */

#include <stdio.h>
main()
{
int cont =0; // El valor inicial de cont es 0
printf(“El valor inicial de cont es %d\n”,cont);
cont++;
printf ( "cont ahora es %d\n", cont );
cont++; printf ( "cont ahora es %d\n", cont );
cont++; printf ( "cont ahora es %d\n", cont );
cont++; printf ( "cont ahora es %d\n", cont ); cont++;
return 0;
}

.
/* Aplicación del operador (--) en un contador inverso de 50 a 1 */
#include <stdio.h>
main()
{
int p;
printf(“¡Hola amigos!\n”);
for(p=50; p>=1;--p){
printf ( " p = %d\t", p );
return 0;
}
Los operadores de incremento y de decremento se pueden utilizar, cada uno de ellos de

dos formas distintas, dependiendo donde se escriba el operador, antes o después del
operando. Si el operador precede al operando ++q, el valor del operando se modificará
antes de que se utilice con otro propósito. Sí sin embargo el operador sigue al operando
q++, entonces el operando de modificará después de ser utilizado.
Ejemplos:
#include <stdio.h>
main()
{
int x =100;
printf ( "Valor de x = %d\n", x );
printf ( "Valor de x = %d\n", ++x );
} /*Salida en pantalla: Valor de x =100 Valor de x = 101 Valor de x = 101*/
/* De otro modo */
#include <stdio.h>
main()
{
int x = 12;
printf ( "Valor de x = %d\n", x++ );
} /*Salida en pantalla: Valor de x=100 Valor de x =100 Valor de x = 101*/
OPERADOR MONARIO sizeof ( tamaño de )

Este operador devuelve el tamaño de su operando en bytes. El operador sizeof siempre
precede a su operando. El operador sizeof permite determinar el número de bytes
ocupados por distintos tipos de datos. Esta información puede ser muy útil cuando se
transfiere el programa a una computadora diferente o una nueva versión de C. También
se utiliza para la asignación dinámica de memoria.
Ejemplos:
/* Programa que determina en tamaño de los tipos de datos */
#include<stdio.h>
main()
{
char c;
int i;

float x;
double d;
printf("char: %d bytes\n", sizeof c);
printf("int: %d bytes\n", sizeof i);
printf("float: %d bytes\n", sizeof x);
printf("double:%d bytes\n",sizeof d);
} /*Salida en pantalla: char: 1 byte int: 2 bytes float: 4 bytesdouble: 8 bytes*/
/* De otro modo */
#include<stdio.h>
main()
{
char c;
int i;
float x;
double d;
printf(“char: %d Byte \n”, sizeof (char));
printf(“int: %d Bytes \n”, sizeof (int));
printf(“float: %d Bytes \n”, sizeof (float));
printf(“double: %d Bytes \n”, sizeof (double));
} /*Salida en pantalla: char: 1 Byte int: 2 Bytes float : 4 Bytes double : 8 Bytes*/
/* Programa que determina el no. de caracteres de un arreglo */

#include<stdio.h>
main()
{
char texto[ ] = “Abecedarios”;
printf(“Numero de caracteres: %d caracteres.\n”, sizeof (texto));
return 0;
} /* Salida en pantalla: Numero de caracteres = 12 caracteres.*/
Los operadores monarios tienen mayor precedencia que los operadores aritméticos. Por
lo tanto si un operador menos monario actúa sobre una expresión aritmética que contiene
uno o más operadores aritméticos, la operación monaria será la primera llevada a cabo a
menos que la expresión aritmética este encerrada entre paréntesis.
La asociatividad de los operadores monarios es de izquierda a derecha.
/*Programa ejemplo de la precedencia de los operadores monarios*/

#include<stdio.h>
main()
{
int x =20, y = 20, q, r;
q = x*++y;
r = x*y;
printf(“q = %d\n”,q);
printf(“r = %d\n”, r);
return 0;
} /* Salida en pantalla: q = 420 r = 420 */

.
OPERADORES RELACIONALES O DE COMPARACIÓN
Los operadores relacionales se utilizan para comprobar las condiciones de las sentencias
de control de flujo. Cuando se evalúa una condición el resultado que se obtiene es falso =
0 si no se cumple y cuando se cumple es cierto = 1. Las evaluaciones de estos
operadores darán como reultados 0 o 1.
Estos operadores se encuentran dentro del mismo grupo de precedencia, que es menor
que la de los operadores monarios y aritméticos. Recordar que el operador de asignación
(=) y el operador de igualdad (= =) son distintos. Ya que el operador de asignación se
utiliza para asignar un valor a un identificador, mientras que el operador de igualdad se
usa para determinar si dos expresiones tienen el mismo valor.
No se pueden utilizar estos operadores en forma indistinta, esto podría provocar errores.
TABLA DE LOS OPERADORES RELACIONALES
OperadorSi
Interpretación
== igual que se cumple si son iguales
!= distinto que se cumple 1 si son diferentes
> mayor que se cumple si el primero es mayor que el segundo
< menor que se cumple si el primero es menor que el segundo
>= mayor o igual que se cumple si el primero es mayor o igual que el segundo
<= menor o igual que se cumple si el primero es menor o igual que el segundo
Ejemplo:
/* Aplicación de operadores relacionales */
#include <stdio.h>
main()
{
int a = 50, b = 20;
printf( "a>b da como resultado %d\n", a>b );
printf( "b<a da como resultado %d\n", b<a );
printf("a==b da como resultado %d\n",a==b);
printf("a>=b da como resultado %d\n",a>=b);
printf("a<=b da como resultado %d\n",a<=b);
printf("a!=b da como resultado %d\n",a !=b);
return 0;
}
Los operadores relacionales no sólo pueden comparar constantes, también pueden

comparar variables.

.
OPERADORES LÓGICOS (CONECTIVAS LÓGICAS)

Los operadores lógicos permiten unir varias comparaciones: 10>5 y 6==6. Los operadores
lógicos son: AND (&&), OR ||, NOT(!).El operador && (AND, en español Y): Devuelve un 1
si se cumplen las dos condiciones. El operador || (OR, en español O): Devuelve un 1 si se
cumple una de las dos condiciones o ambas a la vez.
Operador ! (NOT, no en español): Si la condición se cumple NOT hace que no se cumpla y
viceversa. Tabla de verdad del operador (&&)
Ejemplos: 0&&0 = 0
Operador (&&) 0&&1 = 0
P = a>b&&c>d; 1&&0 = 0
P= 45>15&&15>5; 1&&1 = 1
P= 1 Tabla de verdad del operador (||)
0||0 = 0
0||1 = 1
Operador (||)
1||0 = 1
int a = 50, b = 20, c = 60, d = 40, p; 1||1 = 1
P = b>a||c>d; Tabla de verdad del operador (!)
P= 20>50||60>40; !0 = 1
P= 1 !1 = 0
Operador (!)
Ejemplos:
int a = 45, b = 15, p;
P = !(a==b) P = 1
/* Aplicación de operadores lógicos en un programa */
#include <stdio.h>
main()
{
int a = 15, b = 10;
printf( "a > b && a < b da como resultado %d\n", a > b && a < b );
printf( "b< a || a < b da como resultado %d\n", b < a || a < b );
printf( "!(a == b) da como resultado %d\n", !(a == b ));
return 0;
}
OPERADORES DE ASIGNACIÓN
El operador de asignación ( = ) es el mas usado en lenguaje C.
Este es un operador que se utiliza para asignar un valor a una variable. Este valor puede
ser un número que tecleamos directamente u otra variable:
U7h 8
Su formato es:
identificador = expresión
Ejemplo:
Velocidad = distancia/tiempo;
Area = base*altura/2;
a = 100; o a = b;
Se puden asignar valores a varias variables a la vez: por ejemplo: a = b = c = 30; se les
asigna a las variables a, b, c el valor 30. También se pueden asignar variables al valor de
otra variable. Por ejemplo: a = b = c = d; a, b, c toman el valor d.

C posee, además cinco operadores de asignación para formar expresiones y son los
siguientes: + =, - =, * =, / = y % =.
TABLA FORMATOS Y EQUIVALENCIAS DE LOS OPERADORES DE ASIGNACIÓN
Expresión Expresión equivalente

Variable + = incremento Variable = variable + incremento
Variable - = incremento Variable = variable - incremento
Variable * = incremento Variable = variable * incremento
Variable / = incremento Variable = variable / incremento
Variable % = incremento Variable = variable % incremento
Ejemplos :
Int a = 10, b=8; declaración de variables
Expresión Expresión equivalente Resultado
a += b; a = a + b; a = 18
a - = b; a = a - b; a=2
a * = b; a = a * b; a = 80
a / = b; a = a / b; a=1
a %= b; a = a % b; a=2
//Aplicación de los operadores de asignación en un programa

#include <stdio.h> #include <stdio.h>
main() main()
{ {
int x, y;
x = 8; int suma;
y = 6;
x += 2; suma = 100;
printf( "x = %d\n", x ); printf( "El inicio de suma es %d\n", suma );
x += y; /* esto equivale a x = x + y */ suma+=50;
printf( "x = %d\n", x ); printf( " suma ahora es %d\n", suma );
x -= y; /* esto equivale a x = x - y */ suma-=50;
printf( "x = %d\n", x ); printf( " suma ahora es %d\n", suma );
x *= y; /* esto equivale a x = x * y */ suma*=50;
printf( "x = %d\n", x ); printf( "suma ahora es %d\n", suma );
x /= y; /* esto equivale a x = x / y */ suma/=50;
printf( "x = %d\n", x ); printf( "suma ahora es %d\n", suma );
x %= y; /* esto equivale a x = x % y */ suma%=50;
printf( "x = %d\n", x ); return 0;
return 0; }
}
/*Programa que realiza un conteo de cinco en cinco hasta 100 */

#include <stdio.h>
main()
{
int q;

for(q=0; q<=100; q+=5)
printf( "q = %d\n", q );
return 0;
}
.
OPERADOR CONDICIONAL (?:)
Con este operador se pueden realizar operaciones simples. Una expresión que hace uso
del operador condicional se denomina expresión condicional. Esta expresión se puede
escribir por la sentencia condicional if – else.
formato : Exp1?exp2:exp3
Cuando se evalúa una expresión condicional, exp1 se evalúa primero. Si exp1 es cierta,
entonces se evalúa exp2 y este es el valor de la expresión condicional. Sin embargo si
exp1 es falsa, entonces es evaluada exp3 y este es el valor de la expresión condicional.
Ejemplos:
Dadas las declaraciones
Int x = 1; (x<0)?0:100 (1<0)?0:80
1 no es menor que cero por lo tanto la expresión (1<0) es falsa por consecuencia el
resultado es 100
De otro modo:
Si int x = -1; (x<0)?0:100 (1<0)?0:80
-1 es menor que cero por lo tanto la exp1. (-1<0) es cierta, el resultado será 0.
Ver más ejemplos:
int a =2, b =3, c =4;
c *= (a > 0 && a < = 12) ? ++a : a/b; c = c * ((a > 0 &&a <= 12)? ++a : a/b);
c = c*(( 2 > 0 && 2<= 12)? ++2 : 2/3); c = 4 * (++2) = 4 * (2+1) = 4 * 3 = 12 c = 12
int a =80, b =20, c =30; declaración de variables
c *= (a > 0 && a <= 12) ? ++a : a/b; c = c *( (a > 0 && a <= 12)? ++a: a/b);
c = 30*(( 80 > 0 && 80 <= 12)? ++80 : 80/20);c = 30 * (80/20) = 30 * (4) = 30* 4 = 120
c = 120
De otro modo:
int a = 15, b = 5, c = 7, d = 9, p; declaración ve variables
p = (a > b||c > d) ? -- d : a%d; p = (15 > 5||7 > 9) ? -- 9 : 15%9; p = --9 = 8 p=8
/* Comparación del operador condicional (:?) con la sentencia condicional if-else */

#include <stdio.h>
main()
{
int a, b;
printf(“Introduce los números:\n”);
scanf(“%d%d”,&a,&b);
if(a > b)
printf(“%d >%d \n”,a,b); /*salida en pantalla: a>b*/
else
printf(“Falso”); /*salida en pantalla: Falso*/
return 0;
}
En lenguaje C no se usan los corchetes ( [ ] ), ni las llaves ( { } ) para simplificar

expresiones tipo algebraico. Ya que se usan con otro propósito como representar arreglos
y sentencias compuestas.

.
TABLA DEL GRUPO DE PRECEDENCIA DE LOS OPERADORES EN GENERAL
Categoría Operador Asociatividad

Monarios - ++ -- ! sizeof D a I
Multiplicación, división y resto * / % I a D
Suma y resta - + I a D
Relacionales < <= > >= I a D
Igualdad == != I a D
Y lógica && I a D
O lógica || I a D
Condicional ?: D a I
Asignación = += -= *= /= %= D a I

.
FUNCIONES DE BIBLIOTECA O LIBRERÍAS
Lenguaje C utiliza ciertas funciones de biblioteca para realizar varias operaciones y
cálculos de uso frecuente, estas funciones se encuentran almacenadas en archivos que
se incluyen en el compilador. Para acceder a estos archivos se utiliza la directiva:
#include <archivo.h>
La extensión .h designa un archivo de cabecera (h = header = encabezado) que indica
que se debe incluir al comienzo del programa.
TABLA DE FUNCIONES DE BIBLIOTECA Y DESCRIPCIONES DE USO
Archivo
Función Tipo Propósito Ejemplos
#include<>
Fmod(d1,d2) double Math.h Retorna el resto de d1/d2 con el mismo signo que d1
Abre un archivo llamado s1, del tipo s2.
Fopen(s1,s2) File* Stdio.h
Retorna un puntero al archivo
fprintf(f, ...) int stdio.h Escribe datos en el archivo f (el resto de los argumentos fprintf(f1,"El resultado es %f\n",result);
fputc(c, f) int stdio.h Escribe un carácter en el archivo f fputc(*(p++), stdout);
fputs(s, f) int stdio.h Escribe una cadena de caracteres en el archivo f fputs("esto es una prueba", f1);
Lee i2 elementos, cada uno de tamaño i1 bytes, desde el archivo f hasta la
fread(s,i1,i2,f) int stdio.h fread(buf, strlen(msg)+1, 1, flujo);
cadena s
char*cad;
//asignar memoria a la cadena
malloc.h o
free(p) void Libera un bloque de memoria reservada cuyo principio esta indicado por p. cad=(char *)malloc(50);
stdlib.h
...
free(cad); // liberar memoria
fscanf(f, ...) int math.h Lee datos del archivo f ( el resto de los argumentos fscanf(flujo, %s%f, cad, &f);
Mover el puntero al archivo f una distancia de un byte desde la posición al
Fseek(f,1,f) int Stdio.h
principio del archivo, la posición actual del puntero o el fin del archivo
ftell(f) long int stdio.h Devuelve la posición actual del puntero dentro del archivo f ftell(fichen)
Escribe i2 elementos, cada uno de tamaño 1 bytes, desde la cadena s hasta
fwrite(s, i1, i2, f) int stdio.h num=fwrite(lista,sizeof(char),25,flujo);
el archivo f
while(c=getc(fx) !=EOF {
getc(f) int stdio.h Lee un carácter del archivo f print ("%c",c);
}
int c;
getchar(void ) int stdio.h Lee un carácter desde el dispositivo de entrada estándar while((*c=getchar()) != '\n')
print ("%c",c);
char(punte
gets(s) stdio.h Lee una cadena de caracteres desde el dispositivo de entrada estándar gets(nombre);
ro)
carac=getch();
if (isalnum(carac))
Determina si el argumento es alfanumérico. Devuelve un valor distinto de
isalnum(c) int ctype.h print("%c letra|digito \n",carac);
cero si es cierto; en otro caso devuelve 0
else
printf("%c no letra|digito \n", carac);
Determina si el argumento es alfabético. Devuelve un valor distinto de cero int c;
isalpha(c) int ctype.h
si es cierto; en otro caso devuelve 0. if (isalpha(c)) printf("%c es letra\n",c);
isascii(c) int ctype.h Determina si el argumento es un carácter ASCII. Devuelve un valor int c;

distinto de cero si es cierto; en otro caso devuelve 0 if (isascii(c)) printf('%c es un ascii\n",c)
Determina si el argumento es un carácter ASCII de control. Devuelve un if(iscntrl(c)) printf"%c es un caracter de
iscntrl(c) int ctype.h
valor distinto de cero si es cierto; en otro caso devuelve 0 control\n",c);
Determina si el numero es un digito decimal. Devuelve un valor distinto de
isdigit(c) int ctype.h if(isdigit(c)) printf"%c es un digito\n",c);
cero si es cierto; en otro caso devuelve 0
Determina si el argumento es un carácter ASCII gráfico (hex 0x21 -0x7e;
if(isgraph(c)) printf"%c es un caracter
isgraph(c) int ctype.h octal 041 -176). Devuelve un valor distinto de cero si es cierto; en otro
imprimible(no espacio)\n",c);
caso devuelve 0
Determina si el argumento es una minúscula. Devuelve un valor distinto de if(islower(c)) printf"%c es una letra
islower(c) int ctype.h
cero si es cierto; en otro caso devuelve 0 minuscula\n",c);
Determina si el argumento es un digito octal. Devuelve un valor distinto de if(isodigit(c)) printf"%c es un digito
isodigit(c) int ctype.h
cero si es cierto; en otro caso devuelve 0 octal\n",c);
Determina si el argumento es un carácter ASCII imprimible (hex 0x20
if(isprint(c)) printf("\n"c
isprint(c) int ctype.h -0x7e; octal 040 -176). Devuelve un valor distinto de cero si es cierto; en
imprimible\n",c);
otro caso devuelve 0
Determina si el argumento es un carácter de puntuación. Devuelve un valor if(ispunct(c)) printf"%c es un caracter de
ispunct(c) int ctype.h
distinto de cero si es cierto; en otro caso devuelve 0 puntuacion\n",c);
Determina si el argumento es un espacio en blanco. Devuelve un valor if(isspace(c)) printf"%c es un
isspace(c) int ctype.h
distinto de cero si es cierto; en otro caso devuelve 0 espacio\n",c);
Determina si el argumento es una mayúscula. Devuelve un valor distinto de if(isupper(c)) printf"%c es una
isupper(c) int ctype.h
cero si es cierto; en otro caso devuelve 0 mayuscula\n",c);
Determina si el argumento es un digito hexadecimal. Devuelve un valor ifisxdigit(c)) print"%c es un digito
isxdigit(c) int ctype.h
distinto de cero si es cierto; en otro caso devuelve 0 hexadecimal\n",c)
long lx=-51654,ly;
labs(l) long int math.h Devuelve el calor absoluto de 1
ly=labs(lx);
hdouble x,y;
log(d) double math.h Devuelve el logaritmo natural de d x=10;
y=log(x);
hdouble x,y;
log10(d) double math.h Devuelve el logaritmo (en base 10) de d x=10;
y=log10(x);
void(punte Reserva u bytes de memoria. devuelve un puntero al principio del espacio
malloc(u) stdlib.h cadena=malloc(MAX_CHR);
ro) reservado
double x=2.0, y=4.0, z;
pow(d1, d2) double math.h Devuelve d1 elevado a la potencia d2
z=pow(x,y); //z sera 1.60
printf(...) int stdio.h
putc(c, f) int stdio.h Escribe un carácter en el archivo f putc('*',demo);

putchar(c) int stdio.h Escribe un carácter en el dispositivo de salida estándar putchar('B');
puts(s) int stdio.h Escribe una cadena de caracteres en el dispositivo de salida estándar puts("Desea continuar (s/n);
// visualizar 10 números aleatorios
for (i=0;i<10;i++)
rand( ) int stdlib.h Devuelve un entero positivo aleatorio
printf("%6d\",rand());
rewind(f) void stdio.h Mueve el puntero al principio del archivo f rewind(fx);

scanf(...) int stdio.h Lee datos en dispositivo de entrada estándar scanf('%d %f %c %s, &i, &fp, &c, s);
Código
Formato
%c
Carácter
%d
Entero Decimal

%x
Hexadecimal
%i
Entero Decimal
%f
Numero Real
%o
Octal
%p
Puntero
%s
Cadena
double x, y;
x=0.52;
sin(d), cos(d) double math.h Devuelve el seno de d printf('x =%f radianes\n",x);
y=cos(x);
printf("el coseno de x =%f\n",y);
sinh(d) double math.h Devuelve el seno hiperbólico de d y=sinh(x);
sqrt(d) double math.h Devuelve la raíz cuadrada de d printf("%lf",sqrt(25.0); //se visualiza 5
srand(u) void stdlib.h Inicializa el generador de números aleatorios srand(semilla);
i=strcmp("MNP", "mnp"); // resultado <
0
i=strcmp("abc", "abc"); // resultado = 0
i=strcmp("xy", "abc"); // resultado > 0
string Compara dos cadenas de caracteres lexicográficamente. Devuelve un valor
strcmp(s1, s2) int
strcmp(.h negativo si s1 < s2; 0 si s1 y s2 son idénticas; y un valor positivo si s1 > s2 char s1[80]="Mayo";
char s2[80]="Octubre";
int j;
j=strcmp(s1,s2);
Compara dos cadenas de caracteres lexicográficamente, sin diferenciar

strcmpi(s1, s2) int string.h mayúsculas de minusculas. Devuelve un valor negativo si s1 < s2; 0 si s1 y v=strcmpi(s1,s2);
s2 son idénticas; y un valor positivo si s1 > s2
char *s1="Pepe Luis";

strcpy(s1, s2) char string.h Copia la cadena de caracteres s2 en la cadena s1 char b[12];
strcpy(s2,s1);
cout <<s2<< '\n';
longitud=strlen(nombre);
strlen(s) int string.h Devuelve el numero de caracteres de una cadena char s[81]="Cadena demo”;
printf("La longitud de s es: %d\n"
strlen(s));
char(punter char *cad="----";
strset(c, s) string.h Pone todos los caracteres de s a c (excluyendo el carácter nulo del final \0)
o) strset (cad,'x'); // cad es ahora xxxx
Pasa la orden al sistema operativo. Devuelve cero si la orden se ejecuta
system(s) int string.h correctamente; en otro caso devuelve un valor distinto de cero, tipicamente system(dir);
-1.
tan(d) double math.h Devuelve la tangente de d y=tan(x);
tanh(d) double math.h Devuelve la tangente hiperbólica de d a=tanh(x);
Devuelve el numero de segundos transcurridos despues de un tiempo base
time(p) long int time.h time(&hora);
designado
toascii int ctype.h Convierte el valor del argumento a ASCII c=toascii(entero);
tolower int ctype.h o Convierte una letra a minúscula c=tolower('s'); //c se convierte en 's'

stdlib.h
ctype.h o
toupper int Convierte una letra a mayúscula c=toupper('s'); //c se convierte en 'S'
stdlib.h
.
CAPÍTULO 4
FUNCIONES DE ENTRADA Y SALIDA

Estas funciones permiten la transferencia de datos entre la computadora y los dispositivos
de entrada y salida estándar (teclado y monitor).
Se puede acceder a una función de entrada y salida desde cualquier parte de un
programa con simplemente escribir el nombre de la función, seguido de una lista de
argumentos encerrados entre paréntesis. Los argumentos representan los datos que le
son enviados a la función, algunas funciones de entrada y salida no requieren
argumentos, pero deben aparecer los paréntesis vacíos.
La mayoría de las versiones en C, incluyen una colección de archivos de cabecera que
proporcionan la información necesaria para las distintas funciones de biblioteca. Cada
archivo contiene la información necesaria para la utilización de un determinado grupo de
funciones de biblioteca, estos archivos se incluyen en un programa mediante la directiva
#include<archivo.h> siempre al comienzo de los programas que se vayan a redactar.
Las principales funciones de entrada son: "getchar" ,"scanf" y “gets” mientras que las
correspondientes funciones de salida son: "putchar" , "printf" y “puts”. Todas estas
funciones pertenecen al archivo de acceso a biblioteca #include<stdio.h>.
Las funciones getchar y putchar, permiten la transferencia de caracteres sueltos hacia
adentro y hacia afuera de la computadora. Las funciones scanf y printf son más complejas
y más utilizadas en C. Ya que permiten la transferencia de información de caracteres
sueltos, valores numéricos y cadenas de caracteres. Las funciones gets y puts, permiten
la transferencia de cadenas de caracteres. Con estas funciones ya se pueden redactar
programas sencillos y completos.
FUNCIONES DE E/S getchar() y putchar()

Estas funciones de entrada y salida se consideran las más primitivas del C. Pues
transfieren sólo un carácter leído desde el dispositivo de entrada estándar (el teclado) a la
salida (la pantalla).
Sus formatos son:

variable de carácter = getchar(); putchar(variable de carácter);
La función getchar no requiere argumentos aunque es necesario que un par de paréntesis

vacíos siga a la función, por ejemplo getchar( ).
Variable de carácter es una variable de carácter previamente declarada.
Ejemplo:
/*Programa donde se aplican las funciones getchar() y putchar()*/
#include<stdio.h>
main()
{
char c;
c = getchar( );
putchar( c );
return 0;

}
/*En pantalla se visualizará el carácter que se oprima en el teclado*/
La función getchar también se puede utilizar para leer cadenas de caracteres, leyendo en
una sentencia de control la cadena de carácter a carácter.
.
Ejemplos:
#include<stdio.h>
#include<ctype.h>
#define EOL '\n'
main()
{
char leo[100];
/* Leer una línea de texto en minúsculas y escribirlo en mayúsculas */
int cont, aux;
/* Leer la línea */
for(cont = 0; (leo[cont] = getchar()) != EOL; ++cont)
;
aux = cont; /* apuntar el contador de caracteres*/
for (cont=0; cont<aux; ++cont )
/*Escribir la línea en mayúsculas */
putchar(toupper(leo[cont]));
return 0;
}
Junto con las funciones getchar y scanf, también existe una provisión especial para
indicar el final de un archivo dentro del programa. La definición EOF (end of file = fin de
archivo) se da dentro del paquete de entrada-salida estándar stdio.h y el resultado
devuelto por getchar será -1, siempre que se presente el final del archivo.
La expresión (c = getchar()) != EOF) sirve al propósito dual de obtener desde la entrada
el siguiente carácter y, simultáneamente, comprobar si se ha llegado al final del archivo.
FUNCIONES DE E/S scanf() y printf()

En general las funciones de entrada y salida scanf y printf son las que más se utilizan en
lenguaje C. Ya que estas realizan la transferencia de números, cadenas de caracteres y
otros datos de una forma conveniente y versátil, scanf y printf pueden ser usadas para
datos que estén formateados o en formato libre.
FUNCIÓN DE ENTRADA scanf()

formato: scanf (“cadena de control”, &argl, &arg2, ..., &argn);
La cadena de control se forma de grupos individuales de caracteres de conversión
o especificadores de formato por cada dato de entrada.
Cada carácter de conversión debe comenzar con el signo de porcentaje (%) que indica el
tipo de dato en que esta declarado el programa en cuestión.
Los argumentos o variables representan los datos, estos van precedidos de los signos
ampersand (&), excepto las variables de las cadenas de caracteres. Los signos
ampersand (&) sirven para fijar en alguna dirección de la memoria los datos,tambien se
les llama punteros pues indican donde se encuentran situados los datos en la memoria
de la computadora.
Los arreglos de caracteres no representan direcciones de memoria por lo tanto no van
precedidos del signo ampersand (&).

El especificador de formato %s es muy restringido, para escribir cadenas de caracteres ya
que no tolera ciertos caracteres. Sin embargo el especificador de formato “%[^\n]” soporta
cualquier carácter ASCII, como letras mayúsculas y minúsculas, espacios en blanco, etc.
es ideal para escribir textos extensos.
.
Ejemplos:
{
char f;
int a;
long q;
float x;
double z;
char leo[100];
………………
scanf (“%[^\n], %c %d %ld %f %lf ”,leo,&f,&a,&q,&x,&z);
........................
}
FUNCIÓN DE SALIDA printf()

Sus formatos son:
I printf (“cadena de caracteres”); para pedir datos en pantalla
II printf (“cadena de control”, argl, arg2, ..., argn); para visualizar resultados en
pantalla.
La cadena de control se forma de grupos individuales de caracteres de conversión por

cada dato de entrada. Cada carácter de conversión debe comenzar con el signo de
porcentaje (%) que indica el tipo de dato en que esta declarado el programa en cuestión.
Los argumentos pueden ser constantes, variables simples, nombres de arreglos o
expresiones más complicadas. Los argumentos o variables no representan direcciones de
memoria por lo tanto no van precedidos del signo ampersand (&).
FUNCIONES DE ENTRADA Y SALIDA gets y puts

Estas funciones se utilizan para leer o escribir la entrada y salida de cadenas de
caracteres casi no se usan.
Una función puts puede sustituir a una función printf únicamente cuando se usan cadenas
de caracteres. Por ejemplo, printf(“Hola amigo\n”); se pude escribir puts(“Hola amigos\n”);
Sus formatos son:

gets(variable); puts(variable);
Ejemplo:
#include<stdio.h>
main()
{
char Texto[100]; //Texto es la variable declarada en la cadena de caracteres
gets(Texto);
puts(Texto);
}

FUNCIONES getch() y getche()
Si se quiere introducir a un carácter por el teclado usamos las funciones getch y getche.
Estas esperan a que el usuario introduzca un carácter por el teclado.
La diferencia entre getche y getch, es que la primera saca por pantalla la tecla que hemos
pulsado y la segunda no (la e del final se refiere a echo=eco). Estas funciones pertenecen
al archivo #include<conio.h>.
Ejemplos:
#include <stdio.h>
#include <conio.h>
main()
Salida en pantalla:
{
Introduce una letra: a
char letra;
Has introducido la letra: a
printf( "Introduce una letra: " );
fflush( stdout ); letra = getche();
printf( "\nHas introducido la letra: %c", letra );
}
Ejemplos:
/* Programa que guarda datos en memoria y los visualiza en pantalla */
#include<stdio.h>
main()
{
char f ;
int a;
short e;
long q;
unsigned t;
float x;
double z;
char leo[100];
printf(“*********************************** \n”);
printf(“Escribe tu nombre completo \n”);
gets(leo);
printf(“Teclea los valores de f, a, e, q, t, x, z:\n”);
scanf (“%d %d %hd %ld %u %f %lf ”, &f, &a, &e, &q, &t, &x, &z);
/*Aquí se escriben las formulas*/
printf(“%c\n %d\n %hd\n % ld\n %u\n %f\n %lf\n”, f, a, e, q, t, x, z);
puts(leo); // ó printf(“%s”, leo);
return 0;
}
Las funciones gets y puts no visualizan números, solo cadenas de caracteres

Ejemplo:
#include<stdio.h>
main()
int a,b,c;
char leo[];
printf(“Escribe tu nombre completo \n”);
gets(leo);
printf(“Teclea los valores de a y b: ”);
scanf (“%d %d ”, &a, &b);

puts(leo); //Visualiza la cadena nombre completo
printf(“el valor de C = %d”, c); //Esto es correcto printf sí visualiza numeros
//puts(“el valor de C = %d”); //Esto es incorrecto puts no visualiza numeros
return 0;
}
ESPECIFICACIÓN DEL ANCHO MÍNIMO DE CAMPO
En un especificador de formato, el lenguaje C le permite agregar un entero entre el signo
de porcentaje (%) y la letra. El entero se llama especificador del ancho mínimo de campo,
debido que especifica dicha característica y asegura que la salida alcance el ancho
mínimo. Por ejemplo, %15d, especifica que la salida sea de por lo menos 15 espacios en
blanco alineada hacia la derecha. Esto es muy útil al imprimir una columna de números.
También se puede alinear la salida hacia la izquierda. Para hacerlo se precede con un
signo de menos (-) el entero especificar de ancho mínimo de campo. Por ejemplo, %-15d
especifica que el ancho mínimo es 15, pero alinea la salida a partir del extremo izquierdo
del campo.
Nota: el ancho de campo debe ser mayor que la salida
Ejemplos:
#include<stdio.h>
main()
{
int a = 20, b = 12300; Salida en pantalla:
printf(“%d\n”,a); 20
printf(“%d\n”,b); 12300
printf(“%05d\n”,a); 00015
printf(“%15s”, “Hola\n”); hola
}
/* Alineación de salida hacia la derecha y hacia la izquierda */

#include<stdio.h>
main() Salida en pantalla:
{ 11
int a, b, c, d, e,f; 12 12
a = 1; 123 123
b = 12; 1234 1234
c = 123; 12345 12345
d = 1234; 123456 123456
e = 12345;
f = 123456;
printf(“%10d %-10d\n”,a,a);
printf(“%10d %-10d\n”,b,b);
printf(“%10d %-10d\n”,c,c);
printf(“%10d %-10d\n”,d,d);
printf(“%10d %-10d\n”,e,e);
printf(“%10d %-10d\n”,f,f);
} Salida en pantalla:
Elemento valor
/* Programa que inicializa un arreglo */ 0 10
#include <stdio.h> 1 10
main() 2 10
{ 3 10
int c[10], j; 4 10
5 10
6
APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 10 09 70
7 10
8 10
9 10
for(j = 0;j<=9;j++) c[j] = 10;
printf(" %s %13s\n","Elemento", "Valor");
for(j = 0;j<=9;j++)
printf(" %7d %13d\n", j, c[j]);
}
ESPECIFICADOR DE PRECISIÓN
El especificador de precisión consiste en colocar un punto decimal (.) y un entero justo
después del entero especificador de formato . Por ejemplo, en el especificador %15.2f, la
longitud del ancho mínimo de campo se especifica de 15 caracteres, y el número de
posiciones decimales es 2. Recuerde que el número predeterminado de posiciones
decimales es 6. El especificador de precisión se utiliza para determinar el número de
posiciones decimales en float coma flotante.
Ejemplo:
#include <stdio.h>
main()
{
float a = 36.0, b = 7.0, c;
c = a/b;
printf(“ c = %.2f \n", c );
} /*Salida en pantalla: c = 5.14 sin el especificador de precisión %.2f el resultado sería: c
= 5.142857*/
/* Programa que calcula la raíz cuadrada del producto de dos números*/

#include <stdio.h>
#include <math.h>
main()
{
float x, y, q;
x = 56.0;
y = 6.5;
q = sqrt(x*y);
printf(“ q = %.3f \n", q );
} /*Salida en pantalla: q = 19.078 sin el especificador de precisión %.2f el resultado sería:
q = 19.078784*/

.
ESPECIFICADORES DE FORMATO O CARACTERES DE CONVERSIÓN DE scanf
Carácter Significado
%c El dato es un carácter
%d El dato es un entero decimal
%e El dato es un valor en coma flotante en la forma exponencial base 10
%f El dato es un valor en coma flotante
%g El dato es un valor en coma flotante
%h El dato es un entero corto
%i El dato es un entero decimal
%o El dato es un entero octal
El dato es una cadena seguida por un espacio en blanco
%s
(el carácter nulo \0 se añade automáticamente al final
%u El dato es un entero sin signo
%x El dato es un entero hexadecimal en minúsculas
%[^\n] El dato es una cadena que puede contener espacios en blanco, etc.
ESPECIFICADORES DE FORMATO O CARACTERES DE CONVERSIÓN DE printf
Carácter Significado
%c El dato se muestra como un carácter
%d El dato se muestra como un entero decimal
%e El dato se muestra como un valor en coma flotante con exponente (min)
%E El dato se muestra como un valor en coma flotante con exponente (may)
%f El dato se muestra como un valor en coma flotante sin exponente
El dato se muestra como un valor en coma flotante usando la conversión de tipo e o f,
%g dependiendo del valor; no se muestran ceros no significativos ni el punto decimal si no es
significativo
%h El dato se muestra como un entero corto
%i El dato se muestra como un entero decimal
%o El dato se muestra como un entero octal
%s El dato se muestra como una cadena de caracteres
%u El dato se muestra como un entero sin signo
%x El dato es un entero hexadecimal en minúsculas
%X El dato es un entero hexadecimal en mayúsculas
%p El dato es un puntero
Un prefijo puede preceder ciertas conversiones de caracteres en scanf y printf
Prefijo Significado
h Entero corto o entero sin signo corto
l Entero largo, entero largo sin signo o real de doble precisión
L real en doble precisión largo

.
Ejemplos:
{
int j;
char c;
short k;
long m;
unsigned long d;
double y;
long double z;
char letras[100];
scanf("%d %c %hd %ld %u %f %Lf",&j,&c,&k,&m,&d,&y,&z);
scanf("%[^\n]",letras);
printf("%d %c %hd %ld %u %f %Lf\n",j,c,k,m,d,y,z);
printf("%s\n",letras);
}
¿Que es la función fflush (stdout )? Pues bien, cuando se usa la función printf, no se
escribe directamente en la pantalla, sino en una memoria intermedia,
llamada buffer. Cuando el buffer se llena o cuando se introduce un carácter
'\n' es cuando se envía el texto a la pantalla. En este ejemplo se deseaba
que apareciera el mensaje Introduce una letra: y el cursor se quedara justo
después, es decir, sin usar '\n'. Si se hace esto, en algunos compiladores el
mensaje no se muestra en pantalla hasta que se pulsa una tecla. Y la
función fflush (stdout ) lo que hace es enviar a la pantalla lo que hay en ese
buffer.
Ejemplo:
#include <stdio.h>
#include <conio.h>
main()
{
char letra; Salida en pantalla:
printf( "Introduce una letra: " ); Introduce una letra:
fflush( stdout ); Has introducido la letra: a
letra = getch();
printf("\n has introducido la letra :%c", letra );
}
Como se ve la única diferencia es que en el primer ejemplo se muestra en pantalla lo que

escribimos y en el segundo no.
En vista de que hemos estudiado las principales funciones de entrada y salida. Ya
contamos las bases para diseñar programas sencillos.
Eemplos:
/*Programa que calcula la velocidad de un móvil */
#include<stdio.h>
main()
{
float V, d, t;
printf(“Introduzca los valores de d, t:\n”);
scanf("%f%f",&d,&t);
V = d/t;
printf( “V = %f\n” , V) ;
return 0 ;
}
/*Programas en que se aplica la directiva #define*/
#include <stdio.h>
#define PI 3.1416
main()
{
float radio, perimetro;
radio = 20;
perimetro = 2 * PI * radio;
printf( "El perímetro es: %f", perimetro );
return 0;
}
.
/*Programa que calcula el número de días vividos */
#include<stdio.h>
main()
{
char nombre[50];
int edad;
printf("¿Cómo te llamas?\n ");
gets (nombre);
printf("¿Cuántos años tienes?\n");
scanf("%d",&edad);
edad=edad*365;
printf("%s, has vivido %d dias\n",nombre,edad);
printf("Pulsa cualquier tecla para terminar...");
}
/*Programa que saca el promedio de 3 números*/

#include<stdio.h>
#include<conio.h>
main()
{
float numero;
float promedio=0;
printf("Dame el primer número: ");
scanf("%f",&numero);
promedio+=numero;
printf("Dame el segundo número: ");
promedio+=numero;
printf("Dame el tercer número: ");

promedio+=numero;
promedio=promedio/3;
printf("El promedio es %f\n",promedio);
gotoxy(40,22);
printf("Presione cualquier tecla para terminar...\n");
}
/*Programa que convierte la suma de dos números decimales a octal */

#include<stdio.h>
main()
{
int numero1,numero 2, p;
printf("Numero entero en decimal: ");
scanf("%d", &numero1);
printf("Numero entero en decimal: ");
scanf("%d", &numero2);
p = numero1*numero2;
printf("\n\nSu representacion en octal es %o\n”,p);
printf("Presione cualquier tecla para terminar...");
printf(“Adios.....\n”);
}
/* Conversión de números decimales a hexadecimales */
#include <stdio.h>
main()
{
printf(”Hex (mayúsculas) Hex (minúsculas) Decimal \n”);
printf(”%X %x %d\n”,0,0,0);
printf(”%X %x %d\n”,1,1,1);
printf(”%X %x %d\n”,2,2,2);
printf(”%X %x %d\n”,3,3,3);
printf(”%X %x %d\n”,4,4,4);
printf(”%X %x %d\n”,5,5,5);
printf(”%X %x %d\n”,6,6,6);
printf(”%X %x %d\n”,7,7,7);
printf(”%X %x %d\n”,8,8,8);
printf(”%X %x %d\n”,9,9,9);
printf(”%X %x %d\n”,10,10,10);
printf(”%X %x %d\n”,11,11,11);
printf(”%X %x %d\n”,12,12,12);
printf(”%X %x %d\n”,13,13,13);
printf(”%X %x %d\n”,14,14,14);
printf(”%X %x %d\n”,15,15,15);
printf(”%X %x %d\n”,16,16,16);
printf(”%X %x %d\n”,17,17,17);
printf(”%X %x %d\n”,18,18,18);
printf(”%X %x %d\n”,19,19,19);
printf(”%X %x %d\n”,20,20,20);
printf(”%X %x %d\n”,21,21,21);
printf(”%X %x %d\n”,22,22,22);
printf(”%X %x %d\n”,23,23,23);
printf(”%X %x %d\n”,24,24,24);

}
/*programa interactivo que pregunta el número de calzado, el peso y el color favorito. */

#include <stdio.h>
main()
{
int calzado;
float peso;
char color[20];
printf("Numero de calzado, peso y color favorito:\n");
printf("\n Calzado: ");
scanf("%d", &calzado);
printf("\n Peso: ");
scanf("%f", &peso);
printf("\nColor favorito: ");
scanf("%s", color);
printf("¡El %s!\n", color);
printf("¿Cómo puede gustarte el %s\n", color);
printf("Calzando un %d y pesando %6.2f Kg.?\n", calzado, peso);
}
.
/* Programa que efectúa una multiplicación */
#include<stdio.h>
main()
{
int multiplicador; /* defino multiplicador como un entero */
int multiplicando; /* defino multiplicando como un entero */
int resultado; /* defino resultado como un entero */
multiplicador = 1000 ; /* les asigno valores */
multiplicando = 2 ;
resultado = multiplicando * multiplicador ;
printf("Resultado = %d\n", resultado); /* muestra el resultado */
}
/* programa que convierte grados C a F */

#include <stdio.h>
main()
{
float cels, farh;
farh = 35.0;
cels = 5.0 * ( farh - 32.0 ) / 9.0;
printf(" %fF son %fC\n", farh, cels );
return 0;
}
/* programa que suma de dos números */

#include<stdio.h>
main()
{
int a,b,c;
printf("\nIntroduzca un número: ");

scanf("%d",&a);
printf("\nIntroduzca otro número: ");
scanf("%d",&b);
c=a+b;
printf("%d + %d= %d",a,b,c);
return 0;
}
/*Programa que expresa en hs. min. y seg. un tiempo expresado en seg */

#include<stdio.h>
main()
{
int tiempo,segundos,minutos,horas;
printf("Inserta un tiempo en segundos: ");
scanf("%d",&tiempo);
horas=tiempo/3600;
minutos=tiempo/60-horas*60;
segundos=tiempo-horas*3600-minutos*60;
printf("%d horas %d minutos %d segs",horas,minutos,segundos);
return 0;
}
/*Programa que convierte de metros a pies y pulgadas.*/
#include<stdio.h>
main()
{
float metros,resul,pulg;
int resul2,pulg2;
printf("\nValor en metros: ");
scanf("%f",&metros);
resul=metros*(1/.3048);
resul2=resul;
pulg=resul-resul2;
pulg=pulg*12;
pulg2=pulg;
printf("El resultado es: %d pies %d pulgadas",resul2,pulg2);
return 0;
} /*Salida en pantalla:Valor en metros: 8El resultado es: 26 pies 2 pulgadas*/
/*Programa que saca las raíces de una ecuación de este tipo Ax*x+Bx+C=0 */
#include<stdio.h>
#include<math.h>
void main()
{
float A,B,C,raiz,sol1,sol2;
printf("\nIntroduzca el termino de la x al cuadrado: ");
scanf("%f",&A);
printf("\nIntroduzca el termino de la x: ");
scanf("%f",&B);
printf("\nIntroduzca el termino independiente: ");
scanf("%f",&C);
raiz=B*B-4*A*C;

sol1=(-B-sqrt(raiz))/(2*A);
sol2=(-B+sqrt(raiz))/(2*A);
printf("\nSolución 1= %f",sol1);
printf("\nSolución 2= %f",sol2);
}
.
/* Programa que calcula potencias de base real positiva y exponente entero*/
#include <stdio.h>
float potencia (float, int);
main ( )
{
int exponente;
float base;
printf ("Introducir BASE y EXPONENTE: ");
scanf ("%f%d", &base, &exponente);
if ( base <= 0.0 ) printf ("Solo admito bases positivas \n");
else { if ( exponente > 0 )
printf ("Potencia: %f \n", potencia(base, exponente));
else
printf ("Potencia: %f \n",1.0/potencia(base, -exponente));
}
}
float potencia (float b, int e)
{
if ( b == 1.0 ) return (1.0);
else {
if ( e == 1 ) return ( b );
else {
int i; float p=1.0;
for ( i=1; i<=e; i++ ) p=p*b;
return ( p );
}
}
}

.
CAPÍTULO 5
SENTENCIAS CONDICIONALES Y DE CONTROL

Una sentencia condicional es aquella que verifica el estado de una expresión, puede ser
el valor de una variable o una comparación entre variables, este estado puede resultar
cierto = 1 o falso = 0.
Este tipo de sentencias permiten variar el flujo del programa mediante determinadas
condiciones. Existen varias estructuras diferentes:
SENTENCIA CONDICIONAL if
La sentencia if solo se ejecuta si la condición es cierta = 1. En caso contrario el programa
sigue su curso sin ejecutar la sentencia.
Su formato es:
if (condición) sentencia;
//Programa de ejemplo de la sentencia condicional if

#include<stdio.h>
main ()
{
int a=30,b=50,c;
if(a>b){
printf("cierto");
}
return 0;
}
Ejemplos:
/* Uso de la sentencia condicional if */

#include <stdio.h>
main()
/* Simula una clave de acceso */
{
int usuario,clave=7824;
printf("Introduce tu clave: ");
scanf("%d",&usuario);
if(usuario==clave)
printf("Acceso permitido");
return 0;
}
.
// programa que dice el tipo de angulo
# include <stdio.h>
main()
{
float Angulo;
// Instrucciones ejecutables
printf("Teclee el valor de angulo: ");
scanf("%f",&Angulo);
if (Angulo < 90)
printf("El angulo es agudo");
if (Angulo == 90)
printf("El angulo es recto ");
if (Angulo>90 && Angulo<180)
printf("El angulo es obtuso ");
if (Angulo == 180)
printf("El angulo es llano ");
if (Angulo>180 && Angulo<360)
printf("El angulo es concavo ");
printf("<Intro> Para continuar...");
}// Fin del programa
//Aplicación de los operadores relacionales

#include<stdio.h>
main()
{
int a,b;
printf("Hola amigos.....\n");
printf("INTRODUCE LOS NUMEROS:\n");
scanf("%d%d",&a,&b);

if(a==b)
printf("%d es igual a %d\n",a,b);
if(a!=b)
printf("%d no es igual a %d\n",a,b);
if(a<b)
printf("%d es menor a %d\n",a,b);
if(a>b)
printf("%d es mayor a %d\n",a,b);
if(a<=b)
printf("%d es menor o igual a %d\n",a,b);
if(a>=b)
printf("%d es mayor o igual a %d\n",a,b);
return 0;
}
.
//Programa que dados tres números determina el mayor
#include<stdio.h>
main()
{
int i,j,k,mayor;
printf("i= ");
scanf("%d",&i);
printf("j=");
scanf("%d",&j);
printf("k= ");
scanf("%d",&k);
mayor=i;
if(j>mayor)
mayor=j;
if(k>mayor)
mayor=k;
printf(" El numero mas grande de(%d %d %d) es:%d\n\n",i,j,k,mayor);
printf(“Adios”);
return 0:
}
SENTENCIA CONDICIONAL if-else

Esta sentencia tiene dos opciones. Si se cumple la condición se ejecutará la sentencia1,
de otro modo se ejecutará la sentencia2.
En cualquier caso, el programa continuará a partir de la sentencia2.
Formato:
if(condición)
{

instrucciones (el bloque que se ejecuta si secumple la condición)
}
else {
instrucciones (el bloque que se ejecuta si no se cumple la condición)
}
//Programa de ejemplo de la sentencia condicional if

#include<stdio.h>
main ()
{
int a=30,b=50,c;
if(a>b){
printf("cierto");
}
else{
printf("falso");
}
return 0;
}
.
Ejemplos:
/* Uso de la sentencia condicional if else */
#include<stdio.h>
main()
{
int p;
printf( "Teclea un número " );
scanf( "%d", &p );
if ( p==50 ){
printf ( "El número que introdujo es cincuenta.\n" );
}
else{
printf ( "El número que introdujo no es cincuenta.\n" );
}
}
/* Programa que adivina un número */

#include <stdio.h>
main()
{
int adivina=276, numero;
printf("Introduce un número: ");
scanf("%d",&numero);
if(adivina==numero)
printf("Has adivinado el número\n");
else
printf(“Fallaste…\n”);
}

Nota: en algunos casos se utilizan varias instrucciones en un solo bloque, estas se
agrupan dentro de llaves {}. Sin embargo cuando se utiliza una sola instrucción no es
necesario usar llaves {}. Ver ejemplo anterior.
Ejemplo:
/* Programa que simula una clave de acceso */
#include <stdio.h>
main()
{
int usuario,clave=18276;
printf("Introduce tu clave: ");
scanf("%d",&usuario);
if(usuario==clave){
printf("Acceso permitido");
printf("¡Muy bien!");
}
else
{
printf("Acceso denegado");
printf("¡Fallaste corazón!");
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main() {
int B; B=120;
if (B>50 && B<75) {
printf ("Cierto\n");
} else {
printf ("Falso\n");
}
return 0;
}
/* Programa que dictamina cual es el mayor de dos números dados*/

#include <stdio.h>
main()
{
int a;
int b;
printf("Introduce el primer numero");
scanf("%d",&a);
printf("Introduce el segundo numero");
scanf("%d",&b);
if (a>b)
{
printf("El mayor es %d",a);
}
else
{
printf("El mayor es %d",b);

}
return 0;
}
/*Programa que dice: un triangulo es rectangulo despues de haberle dado los dos catetos
y la hipotenusa. */
#include<stdio.h>
main()
{
int C1,C2,C3,m;
printf("\nIntroduzca los lados: ");
scanf("%d%d%d",&C1,&C2,&C3);
if(C1>C2)
{
m=C2;
C2=C1;
C1=m;
}
if(C3>C2)
{
m=C2;
C2=C3;
C3=m;
}
if(C2*C2==C3*C3+C1*C1)
printf("\nEl triangulo es rectangulo");
else
printf("\nEl triangulo no es rectangulo");
return 0;
}
/* Determinar si un número es menor mayor o igual a cero*/

#include<stdio.h>
main()
{
int i;
printf("i= ");
scanf("%d",&i);
if(i>=0) {
if(i==0)
printf("Numero igual a cero\n\n");
else
printf("Numero mayor que cero\n\n");
}
else printf("Numero menor que cero\n\n");
return 0;
}
/*Si un alumno tiene un promedio >=90 se le hará un 20% de descuento en la colegiatura,

si tiene un promedio >= 80 o <90 el descuento será del 10%, si su promedio <80 pero
>=7 0el descuento será del 5% y si promedia menos de 70 no tendrá descuento.*/

#include <stdio.h>
int main ()
{
float prom = 0,desc = 0,coleg = 5000,tot = 0;
printf("\n\tcual fue tu promedio?: ");
scanf("%f", &prom);
if(prom>=90)
{desc = 0.2;
}
else if(prom>=80&&prom<90) {desc = 0.1;
}
else if(prom>=70&&prom<80){
desc = 0.05;
}
Else
{
desc = 0;
}
tot = coleg-coleg*desc;
printf("\n\tTu colegiatura sera de: %.2f",tot);
return 0;
}
//programa que realiza descuentos de acuerdo al aprovechamiento
#include<stdio.h>
main()
{
float cal1,cal2,cal3,prom,des,tp;
printf("Introduzca las calificaciones: ");
scanf("%f%f%f",&cal1,&cal2,&cal3);
prom=(cal1+cal2+cal3)/3;
if(prom>90)
{
des = 1520*.09;
tp = 1520-des;
printf("el descuento eses: %.2f\n",des);
printf("La mensualidad a pagar es: %.2f",tp);
}
else
{
printf("El total aa pagar es: 1520.00 pesos");
}
return 0;
}
SENTENCIA CONDICIONAL if-else-if

Con este formato el flujo del programa únicamente entra en una de las condiciones. Si
una de ellas se cumple, se ejecuta la sentencia correspondiente y salta hasta el final de la
estructura para continuar con el programa.
Su formato es:
if (condición){
instrucciones;

}
else if (condición){
instrucciones;
}
………
Else{
instrucciones;
}
Ejemplos:
/*Leer dos números enteros y escribir el mayor de ambos o un mensaje si son iguales. */
#include <stdio.h>
main()
{
int a,b;
printf("Dame dos numeros... ");
scanf("%d%d",&a,&b);
if (a>b) printf("El mayor numero es... %d",a);
else if (b>a)printf("El numero mayor es.... %d",b);
else printf("Los numeros son iguales");
return 0;
}
/* Escribe bebé, niño o adulto */
#include <stdio.h>
main()
{
int edad;
printf("Introduce tu edad: ");
scanf("%d",&edad);
if (edad<1)
printf("Lo siento, te has equivocado.");
else if (edad<3) printf("Eres un bebé");
else if (edad<13) printf("Eres un niño");
else if (edad<18) printf("Eres un adolescente");
else if (edad<13) printf("Eres unjoven");
else printf("Eres adulto");
return 0;
}
/* programa que analiza varias condiciones*/

#include <stdio.h>
main()
{
int q;
printf( "Dame un número " );
scanf( "%d", &q );
if ( q<30 ){
printf ( "El número dado era menor de 30.\n" );
}
else if ( q>30 && q<300 ){
printf ( "El número está entre 30 y 300\n" );

}
else if ( q>300 ){
printf( "El número es mayor que 300\n" );
}
}
/*Programa que compara varios números*/

#include <stdio.h>
void main()
{
int num;
printf( "Introduce un número " );
scanf( "%i", &num );
if ( num==50 )
printf ( "Es un 50\n" );
else if ( num==100 )
else if ( num==150 )
else
printf ( "No era ni 50, ni 100, ni 150\n" );
}
// Programa para determinar naturaleza par o impar de un numero
#include <stdio.h>
int main() {
int num; int Res;
printf ("Introduzca un numero entero: ");
scanf ("%d", &num);
Res =num%2;
if (Res==0) {
printf ("El numero es par\n");
} else {
printf ("El numero es impar\n");
}
return 0;
}
SENTENCIA CONDICIONAL switch

Esta sentencia solo evalua expresiones enteras como: tipo char o tipo int nunca, tipo float
y compara el resultado con la constante que aparece en cada case.
En cada case sólo puede escribirse una constante. Switch se suele utilizar en los menús,
de manera que según la opción seleccionada se ejecuten una serie de sentencias.
Su formato es:
switch ( expresión entera){
case 1:
código a ejecutar si la variable tiene elvalor de la opción 1
break;
case 2:
código a ejecutar si la variable tiene elvalor de la opción 2
break;
………………………………………………………………………….

case n:
código a ejecutar si la variable tiene elvalor de la opción n
break;
default:
código que se ejecuta si la variable tieneun valor distinto a los anteriores
}
Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya que se
ejecutan todas hasta que se encuentra la sentencia break. La variable evaluada solo
puede ser declarada en tipo entero o carácter.
default ejecutará las sentencias que incluya, en caso de que la opción escogida no exista.
La sentencia switch sirve par elegir una opción entre varias disponibles. Aquí no tenemos
una condición que se debe cumplir sino el valor de una variable, dependiendo del valor se
cumplirá un caso u otro.
Vamos a ver un ejemplo de múltiples casos con if-else y luego con switch.
Como vemos el código con switch es más cómodo de leer.
.
Ejemplos:
/*Aplicación de la sentencia switch */
#include <stdio.h>
main()
{
int num;
printf( "Introduce un número " );
switch( num )
{
case 1: printf( "Es un 1\n" );
break;
case 2:printf( "Es un 2\n" );
break;
case 3:printf( "Es un 3\n" );
break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
}
/*Ahora con if-eles-if */

#include <stdio.h>
main()
{
int num;
printf( "Hola mundo\n " );
printf( "Introduce un número\n " );

if ( num==1 )
else if ( num==2 )
else if ( num==3 )
else
printf ( "No era ni 1, ni 2, ni 3\n" );
}
/*Uso de la sentencia condicional switch*/

#include<stdio.h>
main()
{
int opcion;
int valor;
printf("conversion:\n");
printf(" 1:dec a hex\n");
printf(" 2:hex a dec\n");
printf(" 3:dec a oct\n");
printf("introducir opcion:");
scanf("%d",&opcion);
switch(opcion){
case 1:
printf("introducir un valor dec:");
scanf("%d",&valor);
printf("\n%d en hex es= %x\n",valor,valor);
break;
case 2:
printf("introducir unvalor hex:");
scanf("%x",&valor);
printf("\n%x en dec es= %d\n",valor,valor);
break;
case 3:
scanf("%d",&valor);
printf("\n%d en oct es=o\n",valor,valor);
break;
default:
printf("¡¡¡E R R O R!!!...\n");
}
return 0;
}
/*Ahora con la sentencia if-else- if*/

#include<stdio.h>
main()
{
char opcion;
int valor;
printf("Opciones:\n");

printf(" 1:dec a hex\n");
printf(" 2:hex a dec\n");
printf(" 3:dec a oct\n");
printf(" 4:octa a dec \n");
printf("introducir opcion:");
if(opcion==1){
scanf("%d",&valor);
printf("%d en hex es: %x\n",valor,valor);
}
else if(opcion==2){
printf("introducir unvalor hex:");
scanf("%x",&valor);
printf("%x en dec es: %d\n",valor,valor);
}
else if(opcion==3){
scanf("%d",&valor);
printf("%d en oct es: %o\n",valor,valor);
}
else if(opcion==4){
printf("introducir un valor octal:");
scanf("%o",&valor);
printf("%o en dec es: %d\n",valor,valor);
}
else
{
printf("¡¡¡E R R O R!!!...\n");
}
return 0;
}
/*Programa que determina los dias de la semana*/

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

/*Descripción: Programa que pasa de pesos a euros o de euros a pesos*/
#include<stdio.h>
main()
{ float cantidad,conversion;
int opcion;
printf("\nIntroduzca la cantidad: ");
scanf("%f",&cantidad);
printf("\n1-Pesos a Euros\n2-Euros a pesos\n");
switch(opcion)
{
case 1: conversion=cantidad/14. 60;
printf("\n%f Pesos son %f Euros",cantidad,conversion);
break;
case 2:
conversion=cantidad*14.60;
printf("\n%f Euros son %f Pesos",cantidad,conversion);
break;
default:
printf("\nOpcion incorrecta");
}
}
Vamos a ver qué pasa si nos olvidamos de algún break: Ejemplo:
#include <stdio.h>
main()
{
int num;
printf( "Introduce un número " ); scanf( "%i", &num );
switch( num )
{
case 1: printf( "Es un 1\n" ); /* Nos olvidamos el break que debería haber aquí */
case 2: printf( "Es un 2\n" ); break;
default:
printf("No es ni 1, ni 2, ni 3\n" );
}
}
Si al ejecutar el programa escribimos un dos tenemos el mensaje Es un dos. Todo

correcto. Pero si se escribe un uno. La salida en pantalla es: Es un 1 Es un 2
¿Por qué? Pues porque cada caso empieza con un case y acaba donde hay un break. Si
no se escribe break aunque haya un case el programa sigue hacia adelante. Por eso se
ejecuta el código del case 1 y del case 2.
Puede parecer una desventaja pero a veces es conveniente. Por ejemplo cuando dos
case deben tener el mismo código. Si no se tuviéra esta posibilidad se tendría que escribir
dos veces el mismo código. También se podrían usar funciones, pero si el código es corto
puede ser más conveniente no usar funciones. Ya se hablará de esto en otro capitulo.
Sin embargo switch tiene algunas limitaciones, por ejemplo no se pueden usar
condiciones en los case. El ejemplo que se ha visto en el apartado if-else-if no se podría
hacer con switch.
Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya que se
ejecutan todas hasta que se encuentra la sentencia ¡Error! Marcador no definido. En una

sentencia condicional switch, la variable evaluada sólo puede ser de tipo entero o
caracter. default ejecutará las sentencias que incluya, en caso de que la opción escogida
no exista.
SENTENCIAS DE CONTROL (Bucles) for, while, do wile, break, continue y goto

Los bucles son sentencias que permiten ejecutar partes del código de forma repetida,
mientras se cumpla una condición.
Esta condición puede ser simple o compuesta de otras condiciones unidas por operadores
lógicos. Nota: break y continue se usan com auxiliares de for, while, do wile y switch.
Los bucles nos ofrecen la solución cuando se quiera repetir una tarea un número
determinado de veces. Suponiendo que se quiera escribir 100 veces el nombre Juan. Con
lo que se ha aprendido hasta ahora se haría lo siguiente:
Ejemplo:
#include <stdio.h>
main()
{
printf( "Juan\n");
printf( "Juan\n");
printf( "Juan\n");
……….
(y así hasta 100 veces)
}
¡que lata! Y si se quiere repetirlo más veces quedaría un programa muy largo.
De otra forma si se usa un bucle for el programa quedaría así:
Ejemplo:
#include <stdio.h>
main()
{
int i;
for ( i=0 ; i<50 ; i++ ) {
printf( "Juan\n" );
}
}
SENTENCIA DE CONTROL for

Esta sentencia de control o ciclo o bucle permite que un conjunto de instrucciones sea
ejecutado hasta que se alcance una cierta condición.
formato:
for (inicio; condición; incremento){
instrucciones………
}
El inicio indica una variable (variable de control) que condiciona la repetición del bucle.Si
hay más, van separadas por comas.
La condición es una expresión relacional que determina cuando finaliza el ciclo.
El incremento define como cambia la variable de control cada vez que se repite el ciclo.
También se puede poner más de una condición. Los elementos de cada sección se
separan por comas. Cada sección se separa por punto y coma.
Como se ve en el ejemplo, si se tiene más de una variable en la sección de inicialización y
en la de incrementos estas deben ir separadas por comas.
Por ejemplo: for (a=1,b=100;a!=b;a++,b- -){

Ejemplos:
#include<stdio.h>//Programa de ejemplo de la sentencia de control for
main()
{
int cont;
for(cont=1;cont<=100;++cont)
{
printf(“%d\t”,cont);
}
}
/* Uso de la sentencia for. */
#include <stdio.h>
main() /* Escribe la tabla de multiplicar */
{
int num,x,result;
printf("Introduce un número: "); scanf("%d",&num);
for (x=0;x<=10;x++){
result=num*x;
printf("\n%d por %d = %d\n",num,x,result);
}
}
/* Programa que visualiza en pantalla el código ASCII */
#include<stdio.h>
main()
{
char x,y;
for(x='A',y='a';x<='Z',y<='z';++x,++y) printf("%c %d %c %d\t",x,x,y,y);
/* Si se usa una sola instrucción no hay necesidad de las llaves { }
}
/*De otro modo cuando se usan dos o más instrucciones hay que utilizar las llaves*/
#include <stdio.h>
void main()
{
int i;
for ( i=0 ; i<100 ; i++ ) {
printf( "Adios\n" ); printf(“Amigos\n”);
}
}
#include <stdio.h>/* Cuidado con el punto y coma al finalizar un for */

main()
{
int i;
for ( i=0 ; i<50 ; i++ ); /* Cuidado con este punto y coma */
{
printf( "Adios\n" );
}
}//Este programa sólo escribirá en pantalla Adios Una sola vez.

/* El programa se debe escribir de la siguente manera*/
#include <stdio.h>
main()
{
int i;
for ( i=0 ; i<100 ; i++ )
{
printf( "Adios\n" );
}
}
SENTENCIA DE CONTROL while
Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta no se
cumple, el programa no se ejecutará.
Naturalmente, si en el interior del bucle hay más de una sentencia, éstas deberán ir entre
llaves para que se ejecuten como un bloque.
formato:
Tipo de dato variable = valor inicial
while(condicion) {
instrucciones;
incremento;
}
/*Programa que escribe los números del 1 al 10 */
#include <stdio.h>
main()
{
int numero=1;
while(numero<=10) {
printf("%d\n",numero);
numero++;
}
}
La condición puede ser cualquier expresión, y cualquier valor distinto de cero es cierto. El
ciclo itera mientras la condición es cierta. Cuando la condición se hace falsa, el control del
programa pasa a la línea siguiente al código del ciclo.
La sentencia puede ser: una sentencia vacía, una sentencia simple o un bloque de
sentencias que se repiten.
También tiene una variable de inicio y un incremento
Ejemplos:
/*Programa que escribe de 1 a n números*/
#include <stdio.h>
main()
{
int a,num;
printf ("Escuela: \n");printf ("Nombre:");printf ("No. de control: \n");
printf ("Materia: \n");
printf ("Maestro: \n");printf ("Hora: \n");
printf ("Introduce el número: \n");
scanf("%d",&num);
a=1;

while (a<=num) {
printf("%d\t",++a);
}
}
/* Programa que lee un número entero y visualizar su tabla de multiplicar utilizando la

sentencia while. */
#include <stdio.h>
void main()
{
int a,b;
printf ("Introduce el número:");
scanf("%d",&a);
b=1;
while (b<=10) {
printf("%d * %d = %d\n",a,b,a*b);
b++;
}
}
.
/*Programa que escribe los números del 1 al 10 */
#include <stdio.h>
main()
{
int numero=1;
while(numero<=10) {
printf("%d\n",numero); numero++;
}
}
/*Programa que suma dos números dados*/

#include<stdio.h>
void main()
{
int numero=2,suma=0;
while(numero<=100) {
suma+=numero;
numero+=2;
printf("La suma es%d\t", suma);
}
}
/* Programa que cuenta de 1 a n números y que suma de 10 en 10 */

#include<stdio.h>
void main()
{
int count=1,suma=0;
float n;
printf("Dame el valor de n:");

scanf("%f",&n);
while(count<=n) {
suma+=10;
printf("%d\t%d\t", suma,count++);
}
}
/* Programa que calcula la media de n números y se interrumpe cuando se oprime 0 */

#include<stdio.h>
void main()
{
int i = 0;
float x, media = 0;
printf("x(%d) ",i);
scanf("%f",&x);
while(x!=0) {
media+=x;
++i;
printf("x(%d) ", i);
scanf("%f", &x);
}
if(i!=0)
printf("La media es: %f\n\n",media/i);
else
printf("No hay media\n\n");
}
/*calcular el promedio de n calificaciones */

#include<stdio.h>
main()
{
float promedio,n, suma = 0;
int cont = 1,calif;
printf("Teclear el valor de n:\n");
scanf("%f",&n);
while(cont<=n) {
printf("Introduce la calificacion:\n");
scanf("%d",&calif);
suma+=calif;
++cont;
}
promedio = suma/n;
printf("El promedio es: %f\n", promedio);
}
/*Programa que calcula el el promedio de n calificaciones con centinela para parar el no.
de calificaciones */
#include<stdio.h>
main()
{
float promedio, suma;

int cont,calif;
cont = 0;
suma = 0;
printf("Teclear el valor de calif, o -1 para finalizar:\n");
scanf("%d",&calif);
while(calif!=-1) {
suma+=calif;
++cont;
printf("Introduce la calificacion:\n");
scanf("%d",&calif);
}
if(cont!=0) {
promedio = suma/cont;
printf("El promedio es: %f\n", promedio);
}
else
printf("!!!E R R O R¡¡¡");
}
.
SENTENCIA DE CONTROL do-while
Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el
programa vuelve a ejecutar las sentencias del bucle.
La única diferencia entre las sentencias while y do-while es que con la segunda el cuerpo
del bucle se ejecutará por lo menos una vez.
Su formato es:
Int inicio;
do{
instrucciones
………………..
incremento;
}while (condición);
/*La suma de números pares*/

#include<stdio.h>
main()
{
do{
suma+=numero;
numero+=2;
}while(numero<=100);
printf("La suma es%d\n", suma);
}
Ejemplos.
/*programa que calcula la media de una serie de números que finaliza al introducir el 999.
El 999 no debe ser tenido en cuenta para la media. */

#include <stdio.h>
main()
{ // Se lee el primer elemento de la secuencia fuera del bucle
int n,c=0,s=0; // Típico esquema mientras.
printf("Dame el primer número:"); scanf("%d",&n);
while(n!=999){
s+=n; // Se trata el elemento leído
c++;
printf("Dame el siguiente nº:"); // Se obtiene el siguiente elemento
scanf("%d",&n);
} if (c) // Sólo se podrá dividir si en la secuencia hay algún nº
printf("\nLa media de los números es %.2f\n",(float)s/c);
else
printf("\nNo se ha leído ningún numero.\n");
}
#include <stdio.h> /* Muestra un menú si no se pulsa 4 */

main()
{
char seleccion;
do{
printf("1.- Comenzar\n");
printf("2.- Abrir\n");
printf("3.- Grabar\n");
printf("4.- Salir\n");
printf("Escoge una opción: ");
selección = getchar();
switch(seleccion)
{
case '1': printf("Opción 1");
break;
case '2':printf("Opción 2");
break;
case '3': printf("Opción 3");
}
}while(seleccion!='4');
}
/*programa que realiza varias operaciones */

#include<stdio.h>
#include<math.h>
main()
{
float cont=1,suma=0;
do {
printf("%f %f %f %f\n",cont,suma, sqrt(cont), sqrt(suma));
suma+=cont; ++cont; sqrt(cont); sqrt(suma);
}while(cont<=10);
}
/*La suma de números pares*/

#include<stdio.h>
main()
{
do{
suma+=numero;
numero+=2;
}while(numero<=100);
printf("La suma es%d\n", suma);
}
.
BUCLES ANIDADOS
Los bucles se pueden anidar uno entre otro. Loa bucles internos y externos no necesitan
ser generados por el mismo tipo de estructura de control. Pero es importante que un bucle
se encuentre incluido dentro del otro. Cada bucle debe ser controlado por un índice
diferente.
Ejemplos:
/*Uso de bucles anidados for*/
#include<stdio.h>
main()
{ int i,j,x,y;
printf("introduzca numeros enteros del 1 al 20\n");
scanf("%d%d",&x,&y);
for(i=1;i<=y;i++) {
for(j=1;j<=x;j++)
printf(" @ "); printf("\n");
}
}
/*Uso bucles anidados, programa que dibuja un triangulo de asteriscos */

#include<stdio.h>
main()
{ int cont,lineas,n;
printf("introduzca el numero de lineas\n");
scanf("%d",&n);
for(lineas=1;lineas<=n;lineas++) {
for(cont=1;cont<=n-lineas;cont++)
putchar(' ');
for(cont=1;cont<=2*lineas-1;cont++)
putchar('*');

printf("\n");
}
retun 0:
}
/*construir un triángulo de n filas de caracteres*/

#include<stdio.h>
main()
{
char car; int filas, nfilas,columnas;
printf("Numero de filas del triangulo: ");
scanf("%d",&nfilas);
for(filas =1,car='\x20';filas<=nfilas;filas++) {
for(columnas =1;columnas<=filas;columnas++) {
car++;
printf("%3c",car);
}
printf("\n");
}
retun 0;
}
/* Calcular la media de varias listas de números */
#include <stdio.h>
main( )
{
int n, contador, bucles,cbucles;
float x,media,suma;
/* Leer el número de listas*/
printf(“Cuantas listas?”);
scanf(“%d”,&bucles);
/* bucle exterior procesa cada lista de números */
for(cbucles=1; cbucles<=bucles; ++cbucles) {
/*inicializar y leer el valor de n*/
suma =0;
printf(“\n lista numero %d\n cuantos numeros?”, cbucles);
scanf(“%d”,&n); /*leer los números*/
for(contador =1; contador<=n;++contador) {
printf(“x=”);
scanf(“%f”,&x);
suma+=x;
} /*fin del bucle interno */
/*calcular la media y escribir la respuesta*/
media =suma/n;
printf(“\n La media se: %f\n”,media);
} /* fin del bucle externo */
return 0;
}
/*Calcular las raíces de una ecuación algebraica utilizando iteraciones */

#include<stdio.h>
#include<math.h>

#define CIERTO 1
#define FALSO 0
main()
{
int indicador =CIERTO,cont=0;
float valor,raiz,test,error;
/*Leer parametros de entrada*/

printf("Valor inicial:\n");
scanf("%f",&valor);
/*Comienza bucle principal*/
while(indicador) {
++cont;
if(cont==50) indicador = FALSO;
test=10 -3*valor*valor;
if(test>0) {
/*Inicializa otra iteración*/
raiz=exp(0.2*log(test));
printf("\nIteracion numero: %2d", cont);
printf(" x=%7.5f",raiz);
error=fabs(raiz-valor);
if(error>0.00001) valor =raiz;/*Repetir el calculo*/
else {
indicador=FALSO;
printf("\n\nRaiz=%7.5f",raiz);
printf("No. de iteraciones = %2d",cont);
}
}
else {
/*Mensaje de error*/
indicador=FALSO;
printf("\nNumeros fuera de rango - intenta con otro valor inicial");
}
}
if((cont==50)&&(error>0.00001)) /*Otro mensaje de error*/
printf("\n\nConvergencia no obtenida tras 50 iteraciones");
return 0;
}
SENTENCIA break
Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una sentencia
switch.
Ejemplos:
#include<stdio.h> /*Programa que utiliza la palabra clave break*/
void main()
{
int x;
for(x=1;x<=10;x++){
if(x==5)

break;
printf("%d\n", x);
}
printf("la corrida se frena cuando x==%d\n",x);
}
/*Interrupción de un ciclo infinito utilizando la instrucción while y break*/

#include<stdio.h>
void main()
{
int c;
printf("introduce un caracter:\n(puslse x para salir)\n");
while(1) {
c=getchar();
if(c=='x') break;
}
printf("El ciclo infinito ha sido interumpido. ¡Hasta pronto!\n");
}
.
#include<stdio.h> /*Interrupcion de un ciclo infinito utilizando la instrucción for */
main()
{
int c;
printf("Introduce un caracter:\n(puslse x para salir)\n");
for(;;) {
c=getchar();
if(c=='x') break;
}
printf("El ciclo infinito ha sido interumpido. ¡Hasta pronto!\n");
}
SENTENCIA continue
Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia continue no
ejecuta las líneas de código que hay a continuación y salta a la siguiente iteración del
bucle.
/*Programa que escribe del 1 al l 100 menos el 25 y el 50 */

#include <stdio.h>
main()
{
Int numero;
For(numero=1;numero<=100;++numero){
If(numero==25||numero==50)
Continue;
Printf(“%d\t”,numero);
}
}
SENTENCIA goto

permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen
programador debe prescindir de su utilización. Es una sentencia muy mal vista en la
programación.
Su formato es: goto etiqueta
Ejemplo:
/*Programa que calcula la velocidad de un móvil aplicando la sentencia goto*/

#include<stdio.h>
main()
{
float V, d, t;
int ref;
ref: printf("Introduzca los valores de d y t: ");
V = d/t;
printf( "V = %f Km/h\n", V);
printf("para regresar pulse el numero indicado: ");
scanf("%d",& ref);
if(ref ==5)
goto ref;
}
/*programa que cuenta del 1 al 10 usando la sentencia goto*/
#include <stdio.h>
int main()
{
int cuenta = 1; /* inicializa cuenta */
inicio: /* etiqueta */
if ( cuenta > 10 ) {
goto fin;
} /* fin de if */
printf( "%d ", cuenta );
cuenta++;
goto inicio; /* ve a (goto) inicio en la lÃƒÂnea 9 */
fin: /* etiqueta */
putchar( 'n' );
return 0; /* indica terminaciÃƒÂ³n exitosa */
} /* fin de main */
/*Programa que calcula la velocidad de un móvil aplicando la sentencia goto*/

#include<stdio.h>
main()
{
float V, d, t;
int etiqueta;
etiqueta: printf("Introduzca los valores de d y t: ");
V = d/t;
printf( "V = %f\n", V);
printf("para regresar pulse el numero indicado: ");
scanf("%d",&etiqueta);
if(etiqueta==5)

goto etiqueta;
return 0;
}
.
CAPÍTULO 6
FUNCIONES (MODULARIDAD)
En capítulos anteriores se vio como utilizar funciones de biblioteca con el fin de realizar
cierto número de operaciones o cálculos de uso común, redacción de textos, etc. Sin
embargo, lenguaje C permite también al programador definir sus propias funciones que
realicen determinadas tareas. Esto permite al programador dividir un programa grande en
un cierto número de componentes más pequeñas, cada una de las cuales con un
propósito único e identificable. Por consecuencia un programa en lenguaje C se puede
modularizar mediante el uso inteligente de las funciones.
Función es un segmento de programa que realiza determinadas tareas para desarrollar un
programa.
A una función también se le puede llamar modulo o parte de un programa.
Tipos de funciones:
Funciones de biblioteca: Aplicadas en programas anteriores como, printf(), scanf(), pow(),
etc.
Existen otras funciones que pueden ser escritas o creadas por los programadores cuyas
características son las siguientes:
Los enunciados se escriben una sola vez para definir la función.
Las funciones se invocan por medio de una llamada de función.
La llamada de una función especifica su nombre y proporciona información en forma de
argumentos, que la función necesita para llevar a cabo su tarea designada.
DEFINICIÓN DE UNA FUNCIÓN

Una función tiene tres componentes principales: la primera línea, la declaración de
argumentos y el cuerpo de la función.
La primera línea contiene la especificación del tipo de dato del valor devuelto por la
función, seguido del nombre de la función y un conjunto de tipos de datos seguidos de
argumentos separados por comas y encerados entre paréntesis

Se puede devolver la información desde la función hasta el punto del programa desde
donde se llamó mediante la sentencia return.
La sentencia return también hace que se devuelva el control al punto de la llamada.
Su formato es:
Tipo de retorno nombre de la función (tipo de dato arg1,...,tipo de dato argn);
El nombre de la función puede ser cualquier identificador válido nunca una palabra clave a
menos que se escriba con letras mayúsculas. (Ejemplo: FLOAT, PRINTF, etc.).
El tipo de valor de regreso: es el tipo de datos del resultado regresado al llamador. Un tipo
de valor de regreso (void) indica que una función no devolverá un valor.
Un tipo de valor de regreso no especificado será tomado por el compilador como tipo int.
Descomposición funcional (top-dow). Modularidad.

El diseño top down consiste precisamente en encontrar la solución de un problema
mediante la descomposición sistemática de la descomposición del problema en
subproblemas cada vez mas simples, aplicando la máxima dividir para vencer.
Modular un programa es dividir un programa en partes.
En un programa con funciones la sentencia return se puede escribir de la siguiente
manera: return (expresión);
Cuando la función retorna algún valor distinto de void es obligatorio escribir al menos una
sentencia return (expresión);
ESTRUCTURA DE UNA FUNCIÓN
El prototipo de una función siempre termina en punto y coma, se escribe al principio de un
programa aplicando los argumentos.
El prototipo de una función le indica al compilador el tipo de dato regresado por la función,
el número de parámetros (argumentos) que la función espera recibir, los tipos de dichos
parámetros y el orden en el cual se esperan dichos parámetros. El compilador usa los
prototipos para corroborar las llamadas de la función
El encabezado ó definición de una función se debe escribir sin punto y coma y es donde
van los parámetros, también aquí inicia el cuerpo de la función.
Ejemlpo:
#include<archivo.h>
...............
Tipo de regreso nombre de la función(tipo de dato arg1,....,tipo de dato argn);
main()
{
Declaraciones;
secuencia de sentencias
nombre de la función(arg1, arg2,....,argn); /*Llamada de la función */
}
/*Definición de la función */
tipo de retorno nombre de la función(tipo de dato arg1,....,tipo de dato argn)
{
declaraciones
instrucciones
return 0; /*Cuando la función no regresa valores*/
return (expresión); /*Cuando la función regresa valor*/
} /*Fin de la función creada por el usuario*/

Nota: (tipo de dato arg1,....,tipo de dato argn) = (parámetros). Parámetros es una lista de
declaraciones de variables separadas por comas.
Ejemplo:
#include<archivo.h>
float proceso(float a, float b,......,float n); /* Prototipo de la función*/
Tipo de retorno. Nombre de la función. Parámetros.

main()
{
int a,b,c,y; /*Declaración de variables*/
y = proceso(a,b,c); /*Llamada de la función*/
printf(“%f.......”,y); /* Salida de resultados* /
..................................................................
}
float proceso(float x,float y,float z) /*Encabezado ó definición de la función */
{
Declaraciones;
Secuencia de sentencias; /*Cuerpo de la función */
return resultado de la operación;
}
Los argumentos declarados en la definición de la función, se llaman argumentos formales,
reciben información de los argumentos actuales.
Los argumentos declarados en la llamada de la función se llaman argumentos actuales,
esta información se envía a los argumentos formales.
Ejemplos:
#include <stdio.h>
int cuadrado(int); /*Prototipo de la función*/
main()
{
int x;
for(x=1;x<=20;x++)
printf(“%d”,cuadrado(x)); /*Llamada de la función*/
printf(“\n”);
}
int cuadrado(int y) /*Definición de función */
{
return y*y;
}
/*Hallar el número mayor*/

#include<stdio.h>
int maximo(int a,int b,int c );
main()
{
int a,b,c,d;
printf("\n Introducir tres valores:\n");
scanf("%d%d%d",&a,&b,&c);
d = maximo(a,b,c); /* Llamada de la función */

printf("El maximo valor es: %d",d);
}
int maximo(int x,int y,int z) /* Definición de la función */
{
int mayor;
if((x>y)&&(x>z)) mayor =x;
if((y>x)&&(y>z)) mayor =y;
if((z>x)&&(z>y)) mayor =z;
return mayor;
}
/* De otro modo */
#include<stdio.h>
int maximo(int,int,int);
main()
{
int a,b,c;
printf(“Introduce los tres digitos:”);
scanf(“%d%d%d”,&a,&b,&c);
printf(“El maximo es:%d\n”, maximo(a,b,c));
return 0;
}
int maximo(int x,int y,int z)
{
int max=x;
if(y>max)
max=y;
if(z>max)
max=z;
return max;
}
/* programa que muestra tabla de multiplicar, producto por sumas números y números
comprendidos entre dos */
#include <stdio.h>
#include <conio.h>
void tabla(int);
void producto(int,int);
void numeros(int,int);
main()
{
int op,n,m;
do {
clrscr ();
printf ("\n MENÚ DE OPCIONES");
printf ("\n ================\n");
printf ("\n 1.- TABLA DE MULTIPLICAR\n");
printf ("\n 2.- PRODUCTO POR SUMAS\n");
printf ("\n 3.- MOSTRAR NÚMEROS COMPRENDIDOS ENTRE DOS\n");
printf ("\n 4.- SALIR \n\n\n\n");
printf ("\n ELIGE UNA OPCION : ");

scanf ("%d",&op);
switch (op){
case 1:clrscr ();
printf ("\n Dame un número : ");
scanf ("%d",&n);
tabla(n); // Llamada a la función
getch();
printf ("\n");break;
case 2:
clrscr ();
do{
printf ("\n Dame un número : ");
scanf ("%d",&n);
}while (n < 0);
do{
printf ("\n Dame otro número : ");
scanf ("%d",&m);
}while (m < 0);
producto(n,m);
printf ("\n");
getch();break;
case 3:clrscr ();
printf ("\n Dame un numero : ");
scanf ("%d",&n);
printf ("\n Dame un numero : ");
scanf ("%d",&m);
numeros(n,m);
printf ("\n");
getch();
break;
}
}while (op != 4);
}
void tabla(int n)
{
int c,p=1;
for (c=1;c<=10;c++){
p=n* c;
printf ("\n %d * %d = %d",n ,c,p);
}
}
void producto(int n, int m)
{
int c,sum=0,aux;
if (n>m) /*Se supone n el menor, en caso de no serlo se intercambian los valores*/
{
aux=n;
n=m;
m=aux;
}
for (c=1;c<=n;c++) sum+=m;

printf ("\n El producto por sumas es %d",sum);
}
void numeros(int n, int m)
{
int c,aux;
if (n > m){
aux = n;
n = m;
m = aux;
}
if (n+ 1 >= m)
printf ("\n No hay números \n");
else for (c=n + 1;c < m ;c++)
printf ("\n %d",c);
}
.
/*programa para calcular el factorial de un entero n */
#include<stdio.h>
int factn( int n);
main()
{
int n,factorial;
printf("Introduce un nunero entero:"); scanf("%d",&n);
printf("El factorial de %d es: %d",n,factn(n));
}
int factn(int numero)
{
int i;
int producto = 1;
if(numero>1)
for(i=2;i<=numero;++i)
producto*=i;
return producto;
}
/*Convertir un carácter de minúscula a mayúscula*/

#include<stdio.h>
#include<ctype.h>
main()
{
char minus,mayus;
char conver(char minus);
printf(“\nTeclea la letra minuscula:”); scanf(“%c”,&minus);
mayus = conver(minus);
printf(“La mayuscula equiv. Es:%c”, mayus);

}
char conver(char c)
{
char caracter;
caracter = toupper(c);
return caracter;
}
/* Programa que calcula los números de fibonacci*/

#include <stdio.h>
#include <conio.h>
long int fibonacci(int);
main()
{
int n,cont;
printf("\n Cuantos numeros de Fibonacci??"); scanf("%d",&n);
for(cont=1;cont<=n;cont++)
printf("\ni=%2d\t F=%ld",cont,fibonacci(cont));
getch();
}
long int fibonacci(int cont)
{
static long int f1=1,f2=1; // Se inicializan en la primera llamada a la función.
long int f;
f=(cont<3)?1:f1+f2; // if (cont<3) f=1; else f=f1+f2;
f2=f1; // se denomina operador condicional
f1=f;
return f;
}
#include<stdio.h>
int p=1, q=2;
void dem(void);
main()
{
printf("Antes de la llamada dem(), p = %d\n y q = %d\n",p,q);
dem();
printf("despues de la llamada dem(), p = %d\n y q = %d\n",p,q);
}
void dem(void)
{
int p = 15, q = 12;
printf(" Declaracion local dem(), p = %d\n y q = %d\n",p,q);
}
PASO DE ARGUMENTOS A UNA FUNCIÓN.

Cuando se le pasa un valor simple a una función mediante un argumento actual, se copia
el valor del argumento actual al argumento formal dentro de la función.
De modo que, se puede modificar el valor del argumento formal dentro de la función, pero
el valor del argumento actual en el punto de la llamada no cambiará.
Al pasar un argumento a una función se denomina paso por valor.

En las funciones definidas por el usuario, los parámetros difieren de los argumentos.
Un parámetro es una entrada en un encabezado de función ó definición de función y sirve
como un relleno para un argumento. Los parámetros de la función son fijos y no cambian
durante la ejecución de un programa.
Un argumento es un valor actual, pasado a la función por el programa que la llama.
Cada vez que la función es llamada se le pueden pasar argumentos diferentes.
Ejemplos:
#include<stdio.h> /*Función que modifica el valor de su argumento*/
int modificar(int); /*prototipo de la función*/
main()
{ int x=5;
printf("\nx=%d desde main, antes de llamar a la función", x);
modificar(x); /*Llamadade la función*/
printf("\nx=%d desde main, despues de llamar a la función", x);
}
int modificar(int x) /* Encabezado de la función ó definición de la función*/
{
x*=3;
printf("\nx=%d desde main, despues de modificar el valor", x);
return x;
}
/* Programa que calcula el cubo de un entero */

#include<stdio.h>
int cubo(int x);
int entrar, contestar;
main()
{
printf(“Teclea un numero entero:”);
scanf(“%d”,&entrar);
contestar = cubo(entrar);
printf(“\n\nEl cubo de %d es %d:”,entrar, contestar);
}
int cubo(int p)
{
int z;
z=p*p*p;
return z;
}
/* Programa que determina si un entero es mayor que otro */

#include<stdio.h>
int x,y,z;
int largo(int a,int b);
main()
{
puts(“introducir dos valores diferentes:”);
scanf(“%d%d”,&x,&y);
z = largo(x,y);
printf(“El valor mayor es:%d:”,z);

}
int largo(int a,int b)
{
if(a>b)
return a;
else
return b;
}
RECURSIVIDAD:
Se llama recursividad a un proceso mediante el cual una función se llama a sí misma de
forma repetida, hasta alcanzar una determinada condición. Este proceso se utiliza para
computaciones repetitivas en las que cada acción se determina en función de un
resultado anterior. Se pueden escribir en esta forma problemas iterativos.
Ejemplos:
*/lcular el factorial de una cantidad entera positiva.
n!=1*2*3*......*n; Esta formula también se puede expresar en forma recursiva.
n!=n(n-1), en la que la acción deseada (el calculo de n!) se expresa en términos de un
resultado anterior, el valor de (n-1)!, que se supone ser conocido. También sabemos que
1! Es por definición el fin del proceso recursivo. */
/*Calcular el factorial de un numero entero positivo utilizando recursividad*/

#include<stdio.h>
int factorial(int n);
main()
{
int n;
printf("n=");
scanf("%d",&n);
printf("n!=%d\n",factorial(n));
}
int factorial(int n)
{
if(n<1)
return 1;
else
return n*factorial(n-1);
}
/*Leer una línea de texto en orden inverso utilizando recursividad */

#include<stdio.h>
#define EOLN '\n'
void main()
{
void inverso(void);
printf("\nIntroduce una linea de texto debajo\n");
inverso();
}
void inverso(void)
{

char c;
if((c=getchar())!=EOLN) inverso();
putchar(c);
}
La salida en pantalla será: Introduce una línea de texto debajo

La dulce mirada de tus bellos ojos reflejan la dulzura tu ser
res ut aruzlud al najelfer sojo solleb sut ed adarim eclud aL
.
/*Las torres de Hanoi resolución utilizando recursividad*/
#include<stdio.h>
void transferir(int, char,char,char);
void main()
{
int n;
printf("\nEstas son las torres de Hanoi\n");
printf("¿Cuantos discos ?");
scanf("%d",&n);
printf("\n");
transferir(n,'I','D','C');
}
void transferir(int n,char desde,char hacia,char temp)
/* Transferir discos desde un pivote a otro */
/* n = númro de discos */
/* desde = origen */
/* temp = almacenamiento temporal */
{
if(n>0){
/*Mover n-1 discos hasta el pivote temporal*/
transferir(n-1,desde,temp,hacia);
/*Mover el n-ésimo disco desde su origen hasta su destino*/
printf("Mover disco %d desde %c hasta %c\n",n,desde,hacia);getch();
/*Mover los n-1 discos desde el pivote temporal hasta su destino*/
transferir(n-1,temp,hacia,desde);
}
}

.
CAPÍTULO 7
ARREGLOS (ARRAYS)
Un arreglo es un identificador que referencia un conjunto de datos del mismo tipo. Imagina
un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro
con sólo cambiar el índice que lo referencia. El índice será un valor entero y positivo. En C
los arreglos comienzan por la posición 0.
Existen aplicaciones que requieren en su proceso múltiples datos que tienen
características comunes,(como un conjunto de datos numéricos, representados por
y1,y2,y3,.......,yn). En tales situaciones es conveniente colocar los datos en un arreglo
donde todos comparten el mismo nombre. Los datos individuales pueden ser caracteres,
enteros, números en coma flotante, etc. Sin embargo, todos deben ser del mismo tipo.
Cada elemento de un arreglo (cada dato individual) es referido especificando el nombre
del arreglo seguido por uno o más índices, con cada índice encerrado entre corchetes.
Cada índice se debe escribir como un entero no negativo. Por ejemplo: Un arreglo de y de
n elementos se expresa como y[0],[1],..........,[n-1], el valor de cada índice se representa
por una constante entera, una variable entera o una expresión más compleja.
Y[0] y[1] y[2]..........................y[n-1]
Y es un arreglo de n elementos .
El número de índices determina la dimensionalidad del arreglo. Si, y[1] indica un arreglo
unidimensional, si t[i][k] hace referencia a un arreglo bidimensional y multidimensionales
como p[i][j].....[n].
Un arreglo es una expresión entera positiva encerrada entre corchetes.
La expresión es generalmente una constante entera positiva.

Su formato es:
Tipo de dato nombre[expresión];
Ejemplos:
int z[200];
char letras[50];
float n[5];
La primera se lee z es un arreglo de 200 elementos.
La segunda define letras como un arreglo de 50 caracteres y así sucesivamente.
Ejemplos:
/*Conversión de minúsculas a mayúsculas*/
#include<stdio.h>
#include<ctype.h>
#define TAMANO 100
main()
{
char texto[TAMANO];
int cont;
/*Leer línea*/
for(cont = 0; cont < TAMANO; ++cont)
texto[cont] = getchar();
/*Escribir la línea en mayúsculas*/
for(cont=0;cont< TAMANO;++cont)
putchar(toupper(texto[cont]));
putchar('\n');
}
/* Programa que cuenta de 0 - 9 */

#include <stdio.h>
main()
{
int vector[10],i;
for (i=0;i<10;i++)
vector[i]=i;
for (i=0;i<10;i++) printf(" %d",vector[i]);
}
Los arreglos también pueden incluir la asignación de valores iniciales. Estos valores
iniciales deben aparecer en el orden en que serán asignados a los elementos individuales
del arreglo, encerrados entre llaves y separados por comas.
Su formato es:
Tipo de datos nombre del arreglo[expresión]={valor1,valor2,.......,valorn};
Expresión es el número de elementos.
Vaor1 es el primer elemento del arreglo y así sucesivamente.
Ejemplos:
int dígitos[10] = {1,2,3,4,5,6,7,8,9}; El índice de un arreglo de n elementos varía
float x[5] = {0,0.12,0,-0.32,0}; de 0 a n-1.
char color[3] = { ‘R’,’E’,’D’};

Su resultado es el siguiente:
Digitos[0] = 1 x[0] = 0 color[0] = ‘R’
Digitos[1] = 2 x[1] = 0.12 color[1] = ‘E’
Digitos[2] = 3 x[2] = 0 color[1] = ‘D’
Digitos[3] = 4 x[3] = -0.32
Digitos[4] = 5 x[4] = 0
Digitos[5] = 6
Digitos[6] = 7
Digitos[7] = 8
Digitos[8] = 9
Si se considera la siguiente declaración

int dígitos[6] = {3,3,3};
static float z[5] = {-0.25,0,0.50};
El resultado elemento por elemento es:
Dígitos[0] = 3 z[0] = -0.25
Dígitos[1] = 3 z[1] = 0
Dígitos[2] = 3 z[2] = 0.50
Dígitos[3] = 0 z[3] = 0
Dígitos[4] = 0 z[4] = 0
Dígitos[5] = 0
Todos los elementos del arreglo se ponen automáticamente en cero, excepto los que han
sido inicializados en la declaración del arreglo.
Las cadenas de caracteres son manejadas de modo diferente, ya que el tamaño del
arreglo se omite. El tamaño será asignado automáticamente. Esto incluye la previsión del
carácter nulo \0, que se añade automáticamente al final de cada cadena.
Ejemplos:
Cuando se asigna una constante de cadena “NOW”.
char prueba[3] = “NOW”
Prueba[0] = ‘N’
Prueba[1] = ‘O
Prueba[2] = ‘\0’
Esto es incorrecto debido al carácter nulo \0, ya que el arreglo debe ser de cuatro
elementos, de tal manera que la forma correcta de escribirse es:
char prueba[4] = “NOW”;
Prueba[0] = ‘N’
Prueba[1] = ‘O’
Prueba[3] = ‘w’
Prueba[2] = ‘\0’
El tamaño de un arreglo se puede definir al principio de un programa por medio de la
directiva #define tamaño 90
Los corchetes pueden estar vacíos, ya que el tamaño se puede especificar como parte de
la definición.
No se pueden incluir valores iniciales en la declaración.
En los arreglos numéricos cada elemento del arreglo representa una cantidad numérica.
Ejemplos:
respecto a la media */
#include<stdio.h>

main()
{
int n, cont;
float media,d,suma=0;
float lista[100]; /*Leer el valor de n*/
printf(“¿Cuántos números para calcular la media?"); scanf("%d",&n);
printf("\n");
for(cont = 0; cont<n; ++cont) { /*Leer los números y calcular la suma*/
printf("i=%d x=",cont+1); scanf("%f",&lista[cont]);
suma+=lista[cont];
} /*Calcular la media y escribir la respuesta */
media = suma/n;
}
}
.
respecto a la media*/
#include<stdio.h>
int n=5;
float lista[] = {3, -2, 12, 4.4, 3.5};
main()
{
int cont;
float media, d, suma = 0;
/*Calcular la media y escribir la respuesta */
for(cont = 0; cont<n; ++cont)
suma+=lista[cont];
media = suma/n;
}
}
PASO DE ARREGLOS A FUNCIONES.

El nombre de un arreglo se puede usar como argumento de una función, permitiendo así
que el arreglo completo sea pasado a la función.
Para pasar un arreglo a una función, el nombre del arreglo debe aparecer solo, sin
corchetes o índices, como un argumento actual dentro de la llamada a la función actual. El
correspondiente argumento formal se escribe de la misma manera, pero debe ser
declarado como un arreglo dentro de la declaración de argumentos formales. Cuando se
declara un arreglo unidimensional como un argumento formal, el arreglo se escribe con un

par de corchetes vacíos. El tamaño de arreglo no se especifica dentro de la declaración
formal de argumentos.
Ejemplos:
/*Pasar arreglo de tres elem. a una función donde estos sean alterados */
#include<stdio.h>
void modificar(int y[3]); /*Declaración de función */
main()
{
int cont, y[3]; /* definición de arreglo */
printf("Desde main, despues de llamar a la función :\n");
for(cont = 0; cont <= 2; ++cont) {
y[cont] = cont+1;
printf("y[%d] = %d\n\n",cont, y[cont]);
}
modificar(y);
printf("Desde main, despues de llamar a la función :\n");
for(cont = 0; cont <= 2; ++cont)
}
void modificar(int y[ ])
{
int cont;
printf("Desde la función, después de modificar los valores :\n");
for(cont = 0; cont <= 2; ++cont){
y[cont] = -9;
}
}
/* Reordenar un arreglo unidimensional de enteros de menor a mayor*/

#include<stdio.h>
#define TAM 100
void reordenar(int y, int z[]);
main()
{
int i,y,z[TAM];
printf("¿Cuántos números serán introducidos?"); /* Leer un valor para y*/
scanf("%d",&y);
printf("\n"); /* Leer la lista de números */
for(i=0; i<y; ++i) {
printf("i = %d z = ", i+1);
scanf("%d", &z[i]);
} /* Reordenar todos los elementos del arreglo */
reordenar(y,z); /* Mostrar lista de números reordenados */
printf("\n\n Lista de números reordenados:\n\n");
for(i=0; i<y; ++i)
printf("i=%d z=%d\n",i+1,z[i]);
return 0;
}
void reordenar(int y, int z[])

{ /* Encontrar el menor del resto de los elementos */
int i,elem,temp;
for(elem = 0; elem<=y-1; ++elem)
for(i = elem + 1; i<y; ++i)
if(z[i]<z[elem]) {
temp = z[elem]; /* Intercambiar los dos elementos */
z[elem] = z[i];
z[i] = temp;
}
}
.
ARREGLOS MULTIDIMENSIONALES
Se definen prácticamente del mismo modo que los arreglos unidimensionales.
En este tipo de arreglos se manejan tablas, filas y columnas.
Por ejemplo: Un arreglo bidimensional de [p][q] , puede ser una tabla de valores que tiene
p filas y q columnas, de tal manera que un arreglo tridimensional puede verse como un
conjunto de tablas algo así como un libro en el cual cada página es una tabla y así
sucesivamente.
Su formato es el siguiente:
Tipo de dato nombre[exp1] [exp2]....... [expn];
Por ejemplo:
fila 1 col 1 col 2 col 3 col ( n-1 ) col n
x[0][0] x[0][1] x[0][2] x[0][n-2] x[0][n-1]
fila 2
x[0][0] x[0][1] x[0][2] x[0][n-2] x[0][n-1]
fila 3
x[1][0] x[1][1] x[1][2] x[1][n-2] x[1][n-1]
fila m
x[m-1][0] x[m-1][1] x[m-1][2] x[m-1][n-2] x[m-1][n-1]

x es un arreglo bidimensional de m x n..
float tabla[30][30];
char pagina[25][80];
static doulbe registros[100 ][66][255];
static duoble registros [P ][Q][R];
Tabla es un arreglo de coma flotante de 30 filas y 50 columnas, esto equivale a 50*50 =

2500 elementos.Página es un arreglo de caracteres con 25 filas y 80 columnas por lo
tanto son 25*80 = 2000 elementos.El arreglo registros puede ser visto como un conjunto
de 100 tablas estáticas en doble precisión, cada una con 66 líneas y 255 columnas
La última definición es similar a la a la definición precedente excepto que las constantes
simbólicas L, M y N definen el tamaño del arreglo. Así los valores asignados a esas
constantes determinarán el tamaño actual del arreglo.
Cuando se defina un arreglo multidimensional se debe tener cuidado con el orden de lo
valores de los valores iniciales al ser asignados al los elementos del arreglo.
Los elementos de un arreglo deben ser asignados por filas, esto es, primero se asignan
los elementos de la primera fila, luego los elementos de la segunda, y así sucesivamente.
Ejemplos:
int elem [3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
Número de elementos 3*4 = 12.
Esto es, una tabla de tres filas y cuatro columnas (cuatro elementos por fila, como los
valores iniciales se asignan por filas (el último índice se incrementará más rápido), el
resultado de esta asignación es:
Elem[0][0] = 1 Elem[0][1] = 2 Elem[0][2] = 3 Elem[0][3] = 4 Elem[1][0] =

5 Elem[1][1] = 6 Elem[1][2] = 7 Elem[1][2] = 8 Elem[2][0] = 9
Elem[2][1] = 10 Elem[2][2] =11 Elem[2][3] = 12
int elem[3][4] = {
{1,2,3,4},
{5,6,7,8},
{9,10,11,12}
};
El par de llaves externas sirve para contener los pares de llaves internas.
Si los valores son menores al número de elementos, estos se rellenan con ceros.
Por ejemplo:
int elem[3][4] = {1,2,3,4,5,6,7,8,9};
int elem[3][4] = {
{1,2,3},
{4,5,6},
{7,8,9}
};
Esta definición asigna valores solo a los tres primeros elementos de cada fila. De este
modo, los elementos de arreglo tendrán los siguientes valores iniciales.
Elem[0][0] = 1 Elem[0][1] = 2 Elem[0][2] = 3 Elem[0][3] = 0 Elem[1][0] = 5 Elem[1]

[1] = 6 Elem[1][2] = 7 Elem[1][2] = 0
Elem[2][0] = 9 Elem[2][1] = 10 Elem[2][2] = 11 Elem[2][3] = 0

int elem [3][4] = {
{1,2,3,0},
{4,5,6,0},
{7,8,9,0}
};
Si la definición se escribe como.

Int elem[3][4] = {1,2,3,4,5,6,7,8,9}; El arreglo tendrá los siguientes valores iniciales.
Elem[2][0] = 9 Elem[2][1] = 0 Elem[2][2] =0 Elem[2][3] = 0
Si el número de valores dentro del par interno es menor al tamaño definido de arreglo,
estos se rellenarán con ceros.
De donde:
Int elementos[3][4] = {
{1,2,3,4},
{5,6,7,8},
{9,0,0,0}
};
Si el número valores dentro de cada par interno de llaves excede el tamaño definido del
arreglo, esto produciría un error en el compilador.
.
Por ejemplo:
Int elem[3][4] = {
{1,2,3,4,5},
{6,7,8,9,10},
{11,12,13,14,15}
};
¡¡¡¡¡¡¡ E s t o e s u n e r r o r!!!!!!!!
Uso de arreglos de tres dimensiones en adelante (multidimensionales).
Por ejemplo:
Int y[10][20][30] = {
{ /*tabla 1 */
{1,2,3,4}, /*fila 1 */
{5,6,7,8}, /*fila 2 */
{9,10,11,12}, /*fila 3 */
},
{ /* tabla 2 */
{ 21,22,23,24} /*fila 1 */
{25,26,27,28} /*fila 2 */
{29,30,31,32} /*fila 3 */
}
};
Este arreglo es una colección de 10 tablas, con 20 filas y 30 columnas.

Por consecuencia:
Y[0][0][0] = 1 y[0][0] [1] = 2 y[0][0] [2] = 3 y[0][0] [3] = 4

y[0][1] [0] = 5 y[0][1] [1] = 6 y[0][1] [2] = 7 y[0][1] [3] = 8
y[0][2] [0] = 9 y[0][2] [1] = 10 y[0][2] [2] =11 y[0][2] [3] = 12

Y[1][0][0] = 21 y[1][0] [1] = 22 y[1][0] [2] = 23 y[0][0] [3] = 24
y[1][1] [0] = 25 y[1][1] [1] = 26 y[1][1] [2] = 27 y[0][1] [3] = 28
y[1][2] [0] = 2 9 y[1][2] [1] = 30 y[1][2] [2] = 31 y[0][2] [3] = 32
El resto de los elementos del arreglo tendrán ceros.
Ejemplos:
/*Programa para calcular la suma de los elementos de dos tablas de enteros */
#include<stdio.h>
#define MAXF 20
#define MAXC 30
main()
{
int nfil,ncol;
/*definición de arreglo */
int a[MAXF][MAXC], b[MAXF][MAXC], c[MAXF][MAXC];
/* Prototipo de funciones */
void leerentrada(int a[][MAXC], int nfil, int ncol);
void calcularsuma(int a[][MAXC], int b[][MAXC], int c[][MAXC], int nfil, int ncol);
void sacarsalida(int c[][MAXC], int nfil, int ncol);
printf("¿Cuantas filas?\n");
scanf("%d",&nfil);
printf("¿Cuantas columnas?\n");
scanf("%d",&ncol);
printf("\n\nLa primera tabla:\n");
leerentrada(a,nfil,ncol);
printf("La segunda tabla:");
leerentrada(b,nfil,ncol);
calcularsuma(a,b,c,nfil,ncol);
printf("\n\nSuma de los elementos:\n\n");
sacarsalida(c,nfil,ncol);
}
void leerentrada(int a[][MAXC], int m, int n) /*Leer tabla de enteros */
{
int fila, colu;
for( fila =0; fila<m; ++fila) {
printf("\nIntroducir datos para la fila no. %2d\n",fila+1);
for(colu=0; colu<n; ++colu)
scanf("%d", &a[fila][colu]);
}
}
void calcularsuma(int a[][MAXC], int b[][MAXC], int c[][MAXC], int m, int n)
/*Sumar los elementos de las dos tablas de enteros */
{
int fila, colu;
c[fila][colu] = a[fila][colu]+ b[fila][colu];
}
}
void sacarsalida(int a[][MAXC], int m, int n)

{
int fila, colu;
printf("%4d",a[fila][colu]);
printf("\n");
}
}
/*Programa que muestra valores de arreglos */

#include<stdio.h>
main()
{
int valores[5];
valores[0] = 100;
valores[1] = 200;
valores[2]= 300;
valores[3] = 400;
valores[4]= 500;
printf(“El arreglo contiene los siguientes valores”);
printf(“ %d %d %d %d %d\n”, valores[0], valores[1], valores[2], valores[3], valores[4]);
}
/* Muestra de valores de arreglos usando for */
#include<stdio.h>
main()
{
int valores[5]; valores[0]=100;
valores[1]=200;
valores[2]=300;
valores[3]=400;
valores[4]=500;
printf("El arreglo contiene los siguientes valores \n");
for(int i=0;i<5; ++i)
printf("%d\n",valores[i]);
}
/*Otra forma de declarar arreglos y la más adecuada */

#include<stdio.h>
main()
{
int valores[5] = {100,200,300,400,500};
int i;
printf("El arreglo contiene los siguientes valores\n");
for(i=0;i<5;++i)
printf(" %d \n", valores[i]);
}
#include<stdio.h>
main()
{
int valores[5] = {100,200,300,400,500};

int i;
printf("El arreglo contiene los siguientes valores\n");
for(i=4;i>=0;--i)
printf(" %d \n", valores[i]);
}
/*Como inicializar arreglos multidimensionales*/

#include <stdio.h>
void imprimir_arreglo(int[][3]);
main()
{
int arreglo1[2][3]={{1,2,3}, {4,5,6}};int arreglo2[2][3]={1,2,3,4,5};int arreglo3[2][3]={{1,2},{4}};
printf("el arreglo1 es:\n");
imprimir_arreglo (arreglo2);
}
{
int i,j;
for(i=0;i<=1;i++){
for(j=0;j<=2;j++)
printf("%d", a[i][j]);
printf("\n");
}
}
#include<stdio.h>
void mostrar_arreglo(int arreglo[],int numero_de_elementos)
{
int i;
for(i=0;i<numero_de_elementos;i++)
printf("%d\n", arreglo[i]);
}
void main()
{
int chicos[5] = {1,2,3,4,5};
int grandes[3] = {1000,2000,3000};
mostrar_arreglo(chicos,5);
mostrar_arreglo(grandes,3);
}
/*Un programa que imprime histogramas */

#include<stdio.h>
#define SIZE 10
main()
{
int n[SIZE] = {19,3,15,7,11,9,13,5,17,1};
int arreglo2[2][3]={1,2,3,4,5};

int arreglo3[2][3]={{1,2},{4}};
int i,j;
printf("%s%13s%17s\n","Elemento", "Valor", "Histograma");
for(i=0;i<=SIZE-1;i++) {
printf("%7d%13d ",i,n[i]);
for(j=1;j<=n[i];j++)
printf("%c", '*');
printf("\n");
}
}
#include<stdio.h>
/* Cómo inicializar arreglos multidimensionales */
void imprimir_arreglo(int [][3]);
main()
{
int arreglo1[2][3]={{1,2,3},{4,5,6}};
int arreglo2[2][3]={1,2,3,4,5};
int arreglo3[2][3]={{1,2},{4}};
printf("El arreglo1 es:\n");
}
{
int i,j;
for(i=0;i<=1;i++) {
for(j=0;j<=2;j++)
printf("%d",a[i][j]);
printf("\n");
}
}
/*Calcular el promedio de 10 calificaciones */

#include<stdio.h>
#define CALIF_M 100
#define ALUMNOS 10
int calif[ALUMNOS];
int i;
int total = 0;
main()
{
for(i = 0; i<ALUMNOS; i++) {
printf("Calif %d es:", i+1);
scanf("%d", &calif[i]);
while(calif[i] > CALIF_M)
{
printf("\nLa calificacion mas alta posible es:%d”, CALIF_M);

printf("\nTeclear la calificacion correcta");
scanf("%d", &calif[i]);
}
total+=calif[i];
}
printf("\n\nEl promedio es: %d", (total/ALUMNOS));
}
/*Como declarar un arreglo tridimensional */

#include<stdio.h>
#include<stdlib.h>
int alea[10][10][10];
int a, b, c;
main()
{
/*Llena el arreglo con nros. al azar la función rand() regresa un número al azar */
/* Se usa un ciclo for para cada subíndice del arreglo */
for(a = 0; a<10; a++) {
for(b = 0; b<10; b++) {
for(c = 0; c<10; c++) {
alea[a][b][c] = rand();
/* La función rand() pertenece al archivo de biblioteca #include<stdlib.h> */
}
}
} /* Ahora despliega los elementos del arreglo de 10 en 10 */
for(a = 0; a<10; a++) {
for(b = 0; b<10; b++) {
for(c = 0; c<10; c++) {
printf("\n alea[%d][%d][%d] = ", a, b, c);
printf("%d ",alea[a][b][c]);
}
printf("\nPresiona una tecla para continuar, CTRL-C to /quit.");
}
}
} /* Fin del main() */
VECTORES Y MATRICES
Un vector es un arreglo unidimensional, es decir, sólo utiliza un índice para referenciar a
cada uno de los elementos.
Formato:
tipo nombre [tamaño];
El tipo puede ser cualquiera de los ya conocidos y el tamaño indica el número de
elementos del vector (se debe indicar entre corchetes [ ]). En el ejemplo, se podrá
observar que la variable i es utilizada como índice, el primer for sirve para rellenar el
vector y el segundo para visualizarlo. Como se ve, las posiciones van de 0 a 9 total 10
elementos.
Ejemplos:
/* Declaración de un arreglo */

#include <stdio.h>
main() /* Contador del 0 - 9 */
{
int vector[10],i;
for (i=0;i<10;i++)
vector[i]=i;
for (i=0;i<10;i++) printf(" %d",vector[i]);
}
Se puede inicializar (asignarle valores) un vector en el momento de declararlo. Si se hace
así no es necesario indicar el tamaño.
Su formato es:
tipo nombre []={ valor 1, valor 2...}
Ejemplos:
int vector[]={1,2,3,4,5,6,7,8};
char vector[]="programador";
char vector[]={'p','r','o','g','r','a','m','a','d','o','r'};
Una particularidad con los vectores de tipo char (cadena de caracteres), es que
deberemos indicar en que elemento se encuentra el fin de la cadena mediante el carácter
nulo (\0). Esto no lo controla el compilador, y tendremos que ser nosotros los que
insertemos este carácter al final de la cadena.
Ejemplo:
/* como se rellena un vector de tipo char. */
#include <stdio.h>
main() /* Rellenamos un vector char */
{
char cadena[20];
int i;
for (i=0;i<19 && cadena[i-1]!=13;i++)
cadena[i]=getche( );
if (i==19) cadena[i]='\0';
else cadena[i-1]='\0';
printf("\n%s",cadena);
}
Se puede ver que en la sentencia de control for se encuentran dos condiciones:

1.- Que no se hayan rellenado todos los elementos (i<19).
2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII es 13. (cadena[x-
i]!=13).
También podemos observar una nueva función llamada getche( ), que se encuentra en
conio.h. Esta función permite la entrada de un carácter por teclado. Después se encuentra
un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el carácter nulo
en el elemento nº20 (cadena[19]). En caso contrario tenemos el else, que asigna el
carácter nulo al elemento que almacenó el carácter ENTER.
En resumen: al declarar una cadena se debe reservar una posición más que la longitud de
la cadena.
Llamadas a funciones con arrays
Como ya se comentó en el tema anterior, los arrays únicamente pueden ser enviados a
una función por referencia. Para ello se debe enviar la dirección de memoria del primer
elemento del array. Por tanto, el argumento de la función deberá ser un puntero.

Ejemplo:
/* Envío de un array a una función. */
#include <stdio.h>
visualizar(int []); /* prototipo */
main() /* rellenamos y visualizamos */
{
int array[25],i;
for (i=0;i<25;i++)
{
printf("Elemento nº %d",i+1);
scanf("%d",&array[i]);
}
visualizar(&array[0]);
}
void visualizar(int array[]) /* desarrollo */
{
int i;
for (i=0;i<25;i++)
printf("%d",array[i]);
}
.
En el ejemplo se puede apreciar la forma de enviar un arreglo por referencia. La función
se podía haber declarado de otra manera, aunque funciona exactamente igual.
declaración o prototipo
void visualizar(int *);
desarrollo de la función
void visualizar(int *arreglo)
Matrices
Una matriz es un array multidimensional. Se definen igual que los vectores excepto que
se requiere un índice por cada dimensión.
formato:
tipo nombre [tamaño 1][tamaño 2]...;
Una matriz bidimensional se podría representar gráficamente como una tabla con filas y
columnas.
La matriz tridimensional se utiliza, por ejemplo, para trabajos gráficos con objetos 3D.
En el ejemplo, se puede ver como se rellena y visualiza una matriz bidimensional. Se
necesitan dos bucles para cada una de las operaciones. Un bucle controla las filas y otro
las columnas.
Ejemplos:
/* Matriz bidimensional. */
#include <stdio.h>
main()
{
int x,i,numeros[3][4];
for (x=0;x<3;x++) /*Se rellena la matriz */
for (i=0;i<4;i++)

scanf("%d",&numeros[x][i]); /* Se visualiza la matriz */
for (x=0;x<3;x++)
for (i=0;i<4;i++)
printf("%d",numeros[x][i]);
return 0;
}
Si al declarar una matriz también se quiere inicializarla, habrá que tener en cuenta el
orden en el que los valores son asignados a los elementos de la matriz.
Ejemplos:
Int i, numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
Quedarían asignados de la siguiente manera:
numeros[0][0]=1 numeros[0][1]=2 numeros[0][2]=3 numeros[0][3]=4
.
También se pueden inicializar cadenas de texto:
Ejemplo:
#include<stdio.h>
main()
{
int i;
char dias[7][10]={"lunes","martes","miércoles","jueves","viernes","sábado","domingo"};
for(i = 0;i<=6;++i)
printf("%s\n",dias[i]);
}
salida en pantalla:
lunes
martes
miércoles
jueves
viernes
sabado
domingo
Para referirse a cada palabra bastaría con el primer índice.

.
CAPÍTULO 8
PUNTEROS
Un puntero es una variable que representa la pocisión (más que el valor ) de otro dato, tal
como una variable o un elemento de arreglo. Estos tienen muchas aplicaciones en C. Por
ejemplo, pueden ser usados para trasvasar información entre una función y sus puntos de
llamada , devuelven varios datos desde una función mediante los argumentos de la
función. También permiten que referencias a otras funciones puedan ser especificadas
como argumentos de una función.
Los punteros se relacionan con los arreglos y proporcionan una vía alternativa de acceso
a los elementos individuales del arreglo.También permite que un arreglo multidimensional
sea reemplazado por un arreglo de punteros de menor dimensión. Esta característica
permite que una colección de cadenas de caracteres sean representadas con un solo
arreglo, incluso cuando las cadenas puedan tener distinta longitud.
PARA QUÉ SIRVE UN PUNTERO Y CÓMO SE USA

Los punteros tienen muchas utilidades, permiten pasar argumentos (o parámetros) a una
función y modificarlos. También permiten el manejo de cadenas y de arrays. Otro uso
importante es que permiten acceder directamente a la pantalla, al teclado y a todos los
componentes de la computadora. Esto se verá más adelante.
Pero si sólo sirvieran para almacenar direcciones de memoria no servirían para mucho.
Deben dejar también la posibilidad de acceder a esas posiciones de memoria. Para
acceder a ellas se usa el operador *, que no se debe confundir con el de la multiplicación.
Si se nota en lo que ha cambiado con respecto al ejemplo anterior, se verá que para
acceder al valor de número usamos *punt en vez de número. Esto es así porque punt
apunta a número y *punt permite acceder al valor al que apunta punt.

Direcciones de variables
Al declarar una variable se le dice a la computadora que reserve una parte de la memoria
para almacenarla. Cada vez que se ejecuta el programa la variable se almacenará en un
sitio diferente, eso no se puede controlar, depende de la memoria disponible y otros
factores misteriosos. Puede que se almacene en el mismo sitio, pero es mejor no fiarse.
Dependiendo del tipo de variable que se declare el ordenador reservará memoria. Cada
tipo de variable ocupa cierto tamaño de memoria en bytes. Por ejemplo si se declara un
char, el ordenador reserva 1 byte (8 bits). Cuando finaliza el programa todo el espacio
reservado queda libre.
Cuando un puntero tiene la dirección de una variable se dice que ese puntero apunta a
esa variable.
La declaración de un puntero depende del tipo de dato al que se quiera apuntar.
Tipos de operadores que se utilizan en punteros

Existen dos operadores especiales de punteros: & y *. El operador & es un operador
monario que devuelve la dirección de memoria de su operando. Por ejemplo: y = &suma;
& coloca en y la dirección de la de la variable suma. Puede decirse que & devuelve la
dirreción.
El operador * es el complemento de &, * es un operador monario que devuelve el valor de
la variable localizada en la dirección que sigue. Por ejemplo: Si y contiene la dirección de
la variable suma, entonces x = *y, coloca el contenido de suma en x.
formato:
tipo_de_dato *nombre_del_puntero;
Si en vez de querer apuntar a una variable tipo char como en el ejemplo hubiese sido de
tipo int, la declaración sería:
int *punt;
Ejemplos:
#include<stdio.h>
void main()
{
int suma, x;
int *y;
suma = 50,
y = &suma,
x = *y;
printf(“El resultado es: %d”,x);
} /*Salida en pantalla: El resultado es: 50*/
/* Programa sencillo donde se aplican punteros */

#include<stdio.h>
void main()
{
int linea[100];
int q = 10;
int *pq;
pq = &q;
printf(“\n\n*pq = %d q = %d”, *pq, q);
*pq = 0;

printf(“\n\n*pq = %d q = %d”, *pq, q);
} /*Salida en pantalla: *pq = 10 q = 10 *pq = 0 q = 0*/
/* Asignaciones de punteros. */
#include <stdio.h>
void main() /* Asignación de direcciones */
{
int a;
int *p1,*p2;
p1=&a;
p2=p1;
printf("%p %p",p1,p2);
} /* Salida en pantalla: 19B2 19B2*/
/* Programa que visualiza un texto en pantalla*/

#include <stdio.h>
#define TEXTO1 "¿ Hola , como "
#define TEXTO2 "le va a Ud. ? "
void main()
{
char palabra[20] , *p ;
int i ;
p = TEXTO1 ;
for( i = 0 ; ( palabra[i] = *p++ ) != '\0' ; i++ ) ;
p = TEXTO2 ;
printf("%s" , palabra ) ;
printf("%s" , p ) ;
}
/*Encuentra una falla muy grave*/

#include <stdio.h>
void main()
{
int *a;
*a = 5;
}
Solución: No se ha dado ninguna dirección al puntero. No se sabe a dónde apunta. Puede

apuntar a cualquier sitio, al darle un valor se esta escribiendo en un lugar desconocido de
la memoria. Esto puede dar problemas e incluso bloquear a la computadora. Se debe
recordar que al ejecutar un programa éste se copia en la memoria, al escribir en cualquier
parte puede que se este cambiando el programa (en la memoria, no en el disco duro).
Existe una forma de saber qué direcciones ha reservado el ordenador. Se trata de usar el
operador & (operador de dirección).
/*Para que el programa se ejecute se debe escribir de la siguiente forma */

/*Se declara la variable 'a' para obtener su valor y dirección.*/
#include <stdio.h>
void main()
{
int a;

a = 10;
printf( "Dirección de a = %p, valor de a = %d\n", &a, a );
} /* Salida en pantalla: Dirección de a = 19D2, valor de a = 10*/
Para mostrar la dirección de las variables se utiliza el especificador de formato %p en

lugar de %d, sirve para escribir direcciones de punteros y variables. El valor se muestra
en hexadecimal.
No se debe confundir el valor de la variable con la dirección donde está almacenada la
variable. La variable 'a' está almacenada en un lugar determinado de la memoria, ese
lugar no cambia mientras se ejecuta el programa. El valor de la variable puede cambiar a
lo largo del programa, lo puede cambiar el usuario. Ese valor está almacenado en la
dirección de la variable. El nombre de la variable es equivalente a poner un nombre a una
zona de la memoria. Cuando en el programa se escribe 'a', en realidad se esta diciendo,
el valor que está almacenado en la dirección de memoria a la que llamamos 'a'.
/* Programa que visualiza la dirección de un número */

#include <stdio.h>
main()
{
int numero;
int *punt;
numero = 43;
punt = &numero;
printf( "Dirección de numero = %p, valor de numero = %d\n", &numero, *punt );
} /*Salida en pantalla: Dirección de numero = 19DC, valor de numero = 43*/
/*De otro modo */
#include <stdio.h>
main()
{
int numero;
int *punt;
numero = 43;
punt = &numero;
*punt = 30;
printf( "Dirección de numero = %p, valor de numero = %d\n", &numero, numero );
} /*Salida en pantalla: Dirección de numero = 19DC, valor de numero = 30*/
/*Programa que muestra la relación entre dos variables enteras, sus direcciones y sus
punteros asociados */
#include <stdio.h>
main()
{
int x = 5;
int y;
int *px; /*Puntero a un entero */
int *py; /* Puntero a un entero */
px = &x; /* Asigna la dirección de x a px */
y = px; /* Asigna el valor de x a y */
py = &y; /*Asigna la dirección de y a py */
printf("\nx = %d &x = %X px = %X *px = %d", x, &x, px, *px);
printf("\ny = %d &y = %X py = %X *py = %d", y, &y, py, *py);

return 0;
}
/*Salida en pantalla:
x = 5 &x = 19F6 px = 19F6 *px = 5
y = 5 &y = 19F4 px = 19F4 *py = 5 */
/*Usando punteros en una comparación, comprobar si dos variables son iguales usando
punteros */
#include <stdio.h>
main()
{
int a, b;
int *punt1, *punt2;
a = 5; b = 5;
punt1 = &a;
punt2 = &b;
if ( punt1 == punt2 )
printf( "Son iguales\n" );
}
Se podría pensar que el if se cumple y se mostraría el mensaje. Son iguales en pantalla.
Pues no es así, el programa es erróneo. Es cierto que a y b son iguales. También es cierto
que punt1 apunta a 'a' y punt2 a 'b'. Lo que se quería comprobar era si a y b eran iguales.
Sin embargo con la condición se esta comprobando si punt1 apunta al mismo sitio que
punt2, comparando las direcciones donde apuntan. Por supuesto a y b están en distinto
sitio en la memoria así que la condición es falsa. Para que el programa funcione se deben
usar los asteriscos:
Ejemplo:
/* Lo correcto es lo siguiente */
#include <stdio.h>
main()
{
int a, b;
int *punt1, *punt2;
a = 5; b = 5;
punt1 = &a; punt2 = &b;
if ( *punt1 == *punt2 )
printf( "Son iguales\n" );
return 0;
} /*Salida en pantalla: Son iguales*/
Ahora sí: se esta comparando el contenido de las variables a las que apuntan punt1 y
punt2. Se debe tener mucho cuidado con esto porque es un error que se cuela con mucha
facilidad.
Cambiando un poco el ejemplo, ahora 'b' no existe y punt1 y punt2 apuntan a 'a'. La
condición se cumplirá porque apuntan al mismo sitio.
ARITMÉTICA DE DIRECCIONES
Es posible desplazar un puntero recorriendo posiciones de memoria. Para se pueden usar
los operadores de suma, resta, incremento y decremento (+, -, ++, - -). Si se tiene un
puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la posición 30000 y se hace: p1=p1+5; el

puntero almacenará la posición 30010, porque apunta 5 enteros por encima ( 10 bytes
más ).
Los punteros son una de las más potentes características de C, pero a la vez uno de sus
mayores peligros. Los punteros permiten acceder directamente a cualquier parte de la
memoria. Esto da a los programas C una gran potencia. Sin embargo son una fuente
ilimitada de errores. Un error usando un puntero puede bloquear el sistema (si se usa ms-
dos o win95, no en Linux) y a veces puede ser difícil detectarlo.
Otros lenguajes no permiten usar punteros para evitar estos problemas, pero a la vez
quitan parte del control que se tiene en C. Casi todos los programas C usan punteros.
Ejemplos:
/*Escribir un programa que de un valor a una variable. Que ésta sea apuntada por un
puntero y sumarle 3 a través del puntero. Luego imprimir el resultado.*/
/* Esta es una posible solución */
#include <stdio.h>
main()
{
int a;
int *b; a = 5;
b = &a;
*b += 3;
printf( "El valor de a es = %d\n", a );
printf( "El valor de a es = %d\n", b );
}
PASO DE PUNTEROS A FUNCIONES
Se ha visto en el capítulo de funciones cómo pasar parámetros y cómo obtener resultados
de las funciones (con los valores devueltos con return). Pero se tiene un inconveniente,
sólo se puede tener un valor devuelto. Los punteros permites modificar varias variables en
una función.
Hasta ahora para pasar una variable a una función se hacía lo siguiente:
Ejmplo:
/* Programa que pasa argumentos a funciones */
#include <stdio.h>
int suma( int a, int b );
main()
{
int var1, var2;
var1 = 5; var2 = 8;
printf( "La suma es : %i\n", suma(var1, var2) );
}
int suma( int a, int b )
{
return a+b;
} /*Salida en pantalla: La suma es 13*/
En este ejemplo se han pasado a la función los parámetros 'a' y 'b' (que no se pueden
modificar) y devuelven la suma de ambos. Suponiendo que se quiera tener la suma pero
además se quiere que var1 se haga cero dentro de la función. Para eso se hace lo
siguiente:

Ejemplo:
#include <stdio.h>
int suma(int *a, int *b )
{
*a=0;
return *a+*b;
}
main()
{
int var1, var2;
var1 = 5; var2 = 8;
printf( "La suma es: %d y a vale: %d\n", suma(&var1, &var2),var1 );
} /*Salida en pantalla: La suma es: 8 y a vale 5*/
En la función suma se ha declarado 'a' como puntero. En la llamada a la función (dentro

de main) se ha escrito & para pasar la dirección de la variable var1. Ya sólo queda hacer
cero a var1 a través de *a = 0;
Es importante no olvidar el operador & en la llamada a la función ya que sin este operador
no se estaría pasando la dirección de la variable sino cualquier otra cosa.
Se pueden usar tantos punteros como se quieran en la definición de la función.
Así se aclara la diferencia entre el valor de una variable (43) y su dirección (19DC). Ahora
veamos como declarar un puntero. Se ha dicho que un puntero sirve para almacenar las
direcciones de memoria. Muchas veces los punteros se usan para guardar las direcciones
de variables. En el capítulo tipos de datos se vio que cada tipo de variable ocupaba un
espacio distinto. Por eso cuando se declara un puntero se debe especificar el tipo de
datos cuya dirección almacenará. En el ejemplo quiere almacenar la dirección de una
variable char.
/* Como apuntar a una función */

#include<stdio.h>
/*Declaración de una función */
int JorImp(char *cadena);
main()
{
char cadena[25] = "Apuntando a una función.";
int (*aptr)(char *cadena);
aptr = JorImp;
if(!(*aptr)(cadena))
printf("Terminado.\n");
return 0;
}
/* Definición de función */
int JorImp(char *cadena)
{
printf("%s\n",cadena);
} /*Salida en pantalla: Apuntando a una función. Terminado.*/
/* Demostración del uso de aritmética de punteros utilizando arreglos*/

#include<stdio.h>
#define MAX 8

int i_arreglo[MAX] = {0,1,2,3,4,5,6,7 };
int *i_ptr, cont;
float f_arreglo[MAX] = {.0,.1,.2,.3,.4,.5,.6,.7 };
float *f_ptr;
main()
{
i_ptr = i_arreglo;
f_ptr = f_arreglo;
for(cont = 0; cont<MAX; cont++)
printf("\n%d\t%f",*i_ptr++,*f_ptr++);
return 0;
}
/* Programa que ilustra la vinculación entre los elementos de un arreglo y sus direcciones
*/
#include<stdio.h>
#include<conio.h>
main()
{
static int x[8] = {20,21,22,23,24,25,26,27};
int i;
for(i = 0; i<7; ++i)
printf("\n= %d\n x[i] = %d *(x+i) = %d &x[i] = %X x+i = %X",i, x[i], *(x+i),&x[i], x+i);
}
CAPÍTULO 9
ESTRUCTURAS
Las estructuras (struct) son agrupaciones de una o más variables de tipos posiblemente
diferentes, agrupadas bajo un solo nombre, que permite un manejo más cómodo de la
agrupación de la información. Las struct son estructuras de datos similares a los registros
(record) de Pascal. La forma general de definición es:
struct tipo_estructura
{
tipo miembro_1;
tipo miembro_2;
.....
tipo miembro_n;
} variable_estructura;
donde tipo_estructura o variable_estructura pueden omitirse pero no ambos. Las

estructuras ayudan a agrupar información relacionada, por ejemplo los datos de un carnet
de identidad, las coordenadas de un punto, etc.
Ejemplos:
/*de declaración de estructuras*/
struct datos
{
char nombre[20];
char direccion[20];
int codigo;
};
struct datos a,b[5]; /* b es un array de estructuras */
Estructuras anidadas: se producen cuando algún miembro de la estructura es a su vez
otra estructura.
Ejemplo:
struct fecha
{
int mes;
int dia;
int anno;
};
struct persona
{
char nombre[20];
struct fecha nacimiento;
};struct persona p;
Ejemplo:
/* Como inicializar una estructura */
#include<stdio.h>
main()
{
struct empleado {
int id;
char nombre[32];
};
/* Inicialización de la estructura */
struct empleado info = {
1,
"b. Smith"
};
printf("Esta es una muestra:\n");
printf("No. ID del empleado: %s\n", info.nombre);
printf("Nombre del empleado: %04d\n\n", info.id);
printf("Cual es su nombre \n");
gets(info.nombre);
printf("Cual es su No. de ID: \n");
scanf("%d", &info.id);
printf("\n Estos son los datos que usted introdujo: \n");
printf("Nombre: %s\n", info.nombre);
printf("No. de ID: %04d\n", info.id);
}
Referencia a los elementos de una estructura

Los elementos individuales de una estructura se referencian utilizando el operador punto
(.), entre el nombre de la variable de tipo estructura y el nombre del miembro de la
estructura. A los elementos de una estructura se les denomina, miembros.
Continuando con las estructuras de los ejemplos anteriores, se pueden tener las
siguientes referencias a miembros:

a.nombre a.dirección a.codigo b[2].codigo
p.nombre p.nacimiento.dia p.nacimiento.mes
Funciones y estructuras
Paso por valor de miembros de una estructura a una función.
Se realiza como si fueran variables simples.
Ejemplo:
para pasar por valor el miembro a.codigo
void funcion f1(int) /*declaración de la función prototipo*/
f1(a.codigo); /* llamada a la función */
void f1(int x) /* definición de la función */
{ ........
..........}
Paso por dirección de miembros de una estructura a una función.
Por ejemplo: Se realiza como si fueran variables simples.

/*para pasar por valor el miembro a.codigo*/
void funcion f1(int *) /*declaración de la función prototipo*/
f1(&a.codigo); /* llamada a la función */
void f1(int *x) /* definición de la función */
{..........
..........}
Hay que tener en cuenta que si lo que se pasa a una función es un miembro de una
estructura que sea un array éste siempre se pasa por dirección (ya que el nombre de un
array es la dirección del primer elemento del mismo).
Paso por valor de estructuras completas a funciones.
En el siguiente ejemplo suma es una función que recibe dos estructuras pasadas por valor
y a su vez devuelve una estructura.
struct vector
{
int x,y,z;
};
struct vector (struct vector, struct vector);
void main()
{
struct vector v1,v2,v3;
...
v3=suma(v1,v2);
...
}
struct vector suma(struct vector v1, struct vector v2)
{
v1.x+=v2.x;
v1.y+=v2.y;
v1.z+=v2.z;
return (v1);
}
Paso por dirección de estructuras completas a funciones.

Cuando las estructuras son muy grandes es más eficiente pasarlas por dirección. En ese
caso se utilizan punteros a estructuras para realizar la comunicación. Para acceder a los
miembros de la estructura debe utilizarse la combinación de los operadores * y punto. Sin
embargo el operador punto tiene más precedencia que * siendo necesario el uso de
paréntesis para asegurar que se aplique primero * y después punto. También puede
utilizarse el operador -> para acceder a los miembros de una estructura referenciada por
un puntero.
Ejemplos:
#include <stdio.h>
struct pareja
{
int a,b;
};
void f1(struct pareja *);
void main()
{
struct pareja p = { 13, 17}; /* inicialización de los miembros*/
f1(&p);
printf("valor de a:%d valor de b:%d\n",p.a,p.b); /* escribe 14 y 18 */
}
void f1(struct pareja *q)
{
q->a++; /* equivalente a (*q.a)++ pero más usado */
q->b++;
}
/* Programa que determina el tamaño de una estructura */
#include<stdio.h
#include<conio.h>
main()
{
struct fecha {
int mes;
int dia;
int anno;
};
struct cuenta {
int cuenta_no;
char cuenta_tipo;
char nombre[100];
float anteriorsaldo;
float nuevosaldo;
float saldo;
struct fecha ultimopago;
} cliente;
printf("%d\n",sizeof cliente);
printf("%d\n",sizeof (struct cuenta));
getch();
return 0;
}

/* Programa que muestra como inicializar una estructura */
#include<stdio.h>
main ()
{
struct empleado {
int ide;
char nombre[35];
};
/* Inicio de la estructura */
struct empleado info = {1,"Jorge Rivera" };
printf("Esta es una muestra:\n");
printf("Nombre del empleado: %s\n",info.nombre);
printf("No. de ide:%04d\n\n",info.ide);
printf("Cual es su nombre?\n");
gets(info.nombre);
printf("Cual es su numero de ide?\n");
scanf("%d",&info.ide);
printf("Estos son los datos que usted introdujo:\n");
printf("Nombre: %s\n",info.nombre);
printf("No. de ide: %04d\n",info.ide);
}
.
/* Programa que actualiza una serie de cuentas de clientes */
#include<stdio.h>
struct fecha {
int mes;
int dia;
int anno;
};
struct cuenta {
char nombre[100];
char calle[100];
char ciudad[100];
int cuenta_no;
char cuenta_tipo;
float anteriorsaldo;
float nuevosaldo;
float pago;
struct fecha ultimopago;
} cliente[100];
main()
/* Leer cuentas de clientes, procesar cada una y mostrar la salida*/
{
int i,n;
void leerentrada(int i);
void escribirsalida(int n);
printf("Sistema de cuentas de clientes\n\n");

printf("¡Cuantos clientes son?");
scanf("%d",&n);
for(i=0; i<n; ++i){
leerentrada(i);
/*Determinar el estado de las cuentas */
if(cliente[i].pago>0)
cliente[i].cuenta_tipo = (cliente[i].pago<0.1*cliente[i].anteriorsaldo)?'o':'c';
else{cliente[i].cuenta_tipo = (cliente[i].anteriorsaldo>0)?'D':'c';
/* Ajuste del estado de cuentas*/
cliente[i].nuevosaldo = cliente[i].anteriorsaldo-cliente[i].pago;
};
for(i=0;i<n;++i)
escribirsalida(i);
}
}
void leerentrada(int i)
/*Leer entrada y actualizar el registro para cada cliente */
{
printf("\ncliente no. %d\n");
printf("\nNombre:\n");
scanf("%[^\n]",cliente[i].nombre);
printf("\ncalle:");
scanf("%[^\n]",cliente[i].calle);
printf("\nciudad:");
scanf("%[^\n]",cliente[i].ciudad);
printf("\ncuenta numero:");
scanf("%[^\n]",cliente[i].cuenta_tipo);
printf("\nsaldo anterior:\n");
scanf("%[^\n]",cliente[i].anteriorsaldo);
printf("\npago actual:\n");
scanf("%[^\n]",cliente[i].pago);
printf("\npago actual:\n");
scanf("%d%d
%d",&cliente[i].ultimopago.mes,&cliente[i].ultimopago.dia,&cliente[i].ultimopago.anno);
}
void escribirsalida(int i)
/* Escribir la informacion para cada cliente*/
{
printf("\nNombre:%s",cliente[i].nombre);
printf("\nNumero de cuenta:%d\n",cliente[i].cuenta_tipo);
printf("\ncalle:%s\n",cliente[i].calle);
printf("\nciudad:%s\n\n",cliente[i].ciudad);
printf("\nSaldo anterior:%7.2f",cliente[i].anteriorsaldo);
printf("\npago actual:%7.2f",cliente[i].pago);
printf("\nnuevo saldo:%7.2f",cliente[i].nuevosaldo);
printf("Estado de cuenta:");
switch(cliente[i].cuenta_tipo) {
case'c':
printf("AL DIA\n\n");
break;
case 'o':

break;
case 'D':
break;
default:
printf("ERROR\n\n");
}
}
/* Programa que demuestra esructuras que tienen otras estructuras */

#include<stdio.h>
#include<conio.h>
int l,a;
long Area;
clrscr();
struct coordenadas {
int x,y;
};
struct rectangulo{
struct coordenadas izquierda;
struct coordenadas derecha;
} micaja;
main()
{
/* Recibe los valores de las coordenadas */
printf("Introduce la coordenada izquierda x:\n");
scanf("%d",&micaja.izquierda.x);
printf("Introduce la coordenada izquierda y:\n");
scanf("%d",&micaja.izquierda.y);
printf("Introduce la coordenada derecha x:\n");
scanf("%d",&micaja.derecha.x);
printf("Introduce la coordenada derecha y:\n");
scanf("%d",&micaja.derecha.y);
/* Calculo de la longitud y el ancho */
a = micaja.derecha.x-micaja.izquierda.x;
l= micaja.derecha.y-micaja.izquierda.y;
/* Cálculo del área */
Area= a*l;
printf(" El área es %ld unidades",Area);
getch();
return 0;
}
/* programa que define una estructura para guardar las entradas */

#include<stdio.h>
#include<conio.h>
int l, a;
long Area;
clrscr();
struct entrada {

char nombre1[20];
char nombre2[20];
char Telefono[10];
};
struct entrada lista[4];
int p;
main()
{
for(p=0; p<4;p++){
printf("Introduce el primer nombre:\n");
scanf("%s", lista[p].nombre1);
printf("Introduce el segundo nombre:\n");
scanf("%s", lista[p].nombre1);
printf("Introduce el no. de telefono:\n");
scanf("%s", lista[p].Telefono);
}
/* Imprime tres líneas en blanco */
printf("\n\n\n");
/* ciclo para desplegar los datos */
for(p=0;p<4;p++) {
printf("Nombre: %s %s ",lista[p].nombre1, lista[p].nombre2);
printf("\t\tTelefono: %s ",lista[p].Telefono);
}
getch();
return 0;
}
CAPITULO 10
ARCHIVOS DE DATOS
Los archivos de datos permiten almacenar información de modo permanente, para ser
accedida o alterada cuando sea necesario.
En C existe un conjunto extenso de funciones de biblioteca para crear y procesar archivos
de datos.
Los archivos secuenciales de datos se pueden dividir en dos categorías. En la primera
categoría están los archivos que contienen caracteres consecutivos. Estos caracteres se
pueden interpretar como datos individuales, como componentes de una cadena o como
números. La segunda categoría es a menudo denominada archivos sin formato y organiza
los datos en bloques contiguos de información. Estos bloques representan estructuras de
datos más complejas como arrays y estructuras (struct).
APERTURA Y CIERRE DE UN ARCHIVO

Cuando se trabaja con archivos secuenciales de datos, el primer paso es establecer un
área de buffer, donde la información se almacena temporalmente mientras se está
transfiriendo entre la memoria y el archivo de datos. Este área de buffer permite leer y
escribir información del archivo más rápidamente de lo que sería posible de otra manera.
El área de buffer se establece escribiendo
FILE *ptvar; donde FILE es un tipo de estructura que establece el área de buffer y ptvar la
variable puntero que indica el comienzo de este área. El tipo de estructura FILE está
definido en stdio.h.
Un archivo de datos debe ser abierto antes de ser creado o procesado. Esto asocia el
nombre del archivo con el área de buffer. También se especifica cómo se va a usar el

archivo.
Para abrir un archivo se usa la función fopen: ptvar = fopen ( nombre_archivo, tipo_archivo);
donde nombre_archivo y tipo_archivo son cadenas. Los tipos de archivo y su significado
son:
"r": Abrir un archivo existente sólo para lectura.
"w": Abrir un nuevo archivo sólo para escritura. Si ya existe, será destruido y creado uno
nuevo en su lugar.
"a": Abrir un archivo para añadir. Si no existe, se crea uno nuevo.
"r+": Abrir un archivo existente para lectura y escritura.
"w+": Abrir un archivo nuevo para lectura y escritura. Si ya existe, será destruido y creado
uno nuevo en su lugar.
"a+": Abrir un archivo existente para leer y añadir. Si no existe, se crea uno nuevo.
La función fopen retorna un puntero al principio del área de buffer asociada con el archivo.
Se retorna un valor NULL si no se puede abrir el archivo.
Un archivo de datos debe cerrarse al final del programa fclose(ptvar);
CREACIÓN DE UN ARCHIVO
Un archivo secuencial de datos puede crearse de dos formas distintas. Una es crear el
archivo directamente, usando un editor. La otra es escribir un programa que introduzca
información en la computadora y la escriba en un archivo. Los archivos sin formato sólo
pueden crearse mediante programa.
Cuando se crea un archivo con un programa, lo habitual es introducir la información desde
el teclado y escribirla en el archivo.
Si el archivo consta de caracteres individuales, se pueden usar la funciones getchar (para
obtener caracteres de teclado) y putc (para escribir caracteres en un archivo).
El formato de putc es el siguiente:
putc(variable_de_tipo_caracter,puntero_al_area_de_buffer);
Un archivo creado de esta manera puede ser visualizado de distintas formas:
Usando una orden del sistema operativo tal como type, usando un editor o escribiendo un
programa que lea el contenido y lo muestre. Para ello se pueden utilizar las funciones getc
(para leer caracteres de un archivo) y putchar (para escribir caracteres por pantalla).
El formato de getc es:
variable_de_tipo_caracter=getc (puntero_al_area_de_buffer);
Los archivos de datos que contienen sólo cadenas de caracteres pueden crearse y leerse
más fácilmente con programas que utilizan funciones de biblioteca especialmente
orientadas para cadenas: fgets y fputs.
Muchos archivos de datos contienen estructuras de datos más complicadas, como struct
que incluyen combinaciones de información, caracteres y números. Tales archivos se
pueden procesar.
Formatos de las funciones fscanf y fprintf :

fprintf(puntero_area_buffer,cadena_control,argto1,..,argton);
fscanf(puntero_area_buffer,cadena_control,&argto1,..,&argton);
Una vez creado un archivo de datos surge la pregunta de cómo detectar una condición de
fin de archivo. La función EOF sirve para este propósito (válida para un archivo secuencial
con o sin formato). Esta función devuelve un valor distinto de cero (cierto) si detecta una
condición de fin de archivo y un valor cero (falso) si no se detecta.
PROCESAMIENTO DE UN ARCHIVO
Para actualizar los registros dentro de un archivo de datos hay varios enfoques. Uno de
ellos consiste en leer cada registro del archivo, actualizarlo y escribirlo en el mismo

archivo. Sin embargo es difícil leer y escribir datos con formato al mismo archivo sin
alterar la ordenación de los elementos dentro del archivo.
Otro enfoque es trabajar con dos archivos diferentes: un archivo antiguo (la fuente) y otro
nuevo. Se lee cada registro del archivo antiguo, se actualiza y se escribe en el archivo
nuevo.
ARCHIVOS SIN FORMATO

Algunas aplicaciones implican el uso de archivos para almacenar bloques de datos, donde
cada bloque consiste en un número fijo de bytes contiguos. Cada bloque representará
generalmente una estructura de datos compleja, como una struct o un array. Para estas
aplicaciones sería deseable leer o escribir el bloque entero del archivo de datos en vez de
leer o escribir separadamente las componentes individuales de cada bloque.
Las funciones fread y fwrite deben usarse en estas situaciones. A estas funciones se las
conoce como funciones de lectura y escritura sin formato. Igualmente se hace referencia a
estos archivos de datos como archivos de datos sin formato.
Cada una de estas funciones necesita cuatro argumentos:
- la dirección del bloque de datos
- el tamaño del bloque de datos
- el número de bloques a transferir
- el puntero a un archivo secuencial
Ejemplos:
fwrite(&cliente, sizeof(registro), 1, ptvar);
fread(&cliente, sizeof(registro), 1, ptvar);
donde cliente es una variable estructura de tipo registro y ptvar un puntero a archivo
secuencial.
Ejemplo:
/*Como abrir y cerrar un archivo */
#include<stdio.h>
enum {EXITO, FRACASO};
main()
{
FILE*aptrf;
char nomarchivo[] = "Juan.Polainas";
int valdevol = EXITO;
if((aptrf = fopen(nomarchivo, "r")) == NULL) {
printf("El archivo no se puede abrir\n %s.\n", nomarchivo);
valdevol = FRACASO;
}
else{
printf("El valor de aptrf es: 0x%p\n", aptrf);
printf("Listo para cerrar el archivo.");
fclose(aptrf);
}
return valdevol;
}
FUNCIONES RELACIONADAS CON ARCHIVOS TIPO TEXTO

Existe un número muy grande de funciones para el manejo de archivos, entre las mÁs
importantes estan:
Operaciones sobre los streams estándar:

printf() escribe una línea de texto en stdout;
putchar() escribe un caracter en stdout;
puts() escribe un arreglo caracteres en stdout;
scanf() lee una línea de texto de stdin;
getchar() lee un caracter de stdin;
gets() lee un arreglo caracteres de stdin.
Operaciones sobre streams definidos por usuario:
fscanf() escribe línea texto en stream;
fputc() escribe un caracter en stream;
fputs() escribe un arreglo caracteres en stream;
fscanf() lee una línea de texto de stream;
fgetc() lee un caracter de stream;
fgets() lee un arreglo caracteres de stream;
fread() lee n bytes, en binario, del stream;
fwrite() escribe n bytes, en binario, al stream;
fseek() posiciona un apuntador en una posición del archivo;
ftell() obtienen la posición del apuntador en un archivo;
feof() prueba si se esta apuntando al indicador de fin archivo;
fclose() cierra el archivo apuntado por el stream;
ferror() prueba el indicador de error, 0 si no hubo er
Ejemplos;
Ejemplo uso fgets(), fputs(), gets() y puts
Sus formatos son;
1. char *fgets(char *s, int n, FILE *stream)
2. int fputs(char *s, FILE *stream)
3. char *gets(char *s)
4. int puts(char *s)
Nota: Una línea esta compuesta de caracteres hasta que aparece el caracter de cambio
de línea LF: '\n'. Como dato curioso fgets() transmite caracter '\n' mientras que gets lo
elimina. Por otra parte, puts lo regenera mientras que fputs no hace nada.
Ejemplos:
#include<stdio.h>
main()
{
char ligne[128];
FILE *in, *out;
while(gets(ligne) !=NULL)
puts(ligne);
in = fopen("fuente", "rb");
out = fopen("destino", "wb");
while(fgets(ligne, 128, in) !=NULL)
fputs(ligne, out);
}
Uso de las funciones fscanf(), fprintf() y fclose()

Sus formatos son:
1. int fprintf(FILE * stream)
2. int fscanf(char *format ...)
3. int fclose(FILE *stream)
4. int ferror(FILE *stream)

Ejemplo de uso:
while ((n=fscanf(flux,''%g'',%note[i]) ==1) {
...
}
if (n != EOF) {
int code; /* Se produjo un error en la lectura */
code=ferror(flux);
fprintf(stderr, ''Error %d lectura archivo: /users/notes'', code);
fclose(flux);
exit(1);
}
Uso del feof()
int feof(FILE *stream)
Ejemplo de uso:
while (fscanf(flux,''%g'',&note[i]) ==1) {
...
}
if ( !feof(flux) ) /* error en la lectura */
{
int code;
code=ferror(flux);
fprintf(stderr, ''Error %d lectura archivo:/users/notes'', code);
fclose(flux);
exit(1);
}
Uso del fread() y fwrite()
size_t fread(void *ptr, size_t size, sizer_t nmemb, FILE
*stream)
size_t fwrite(void *ptr, size_t size, size_t nmemb, FILE
*stream)
Ejemplos:
int i,tab[1000];
struct datos{
int edad;
char nombre[10];
char apellido[15];
};
FILE *flux;
struct datos empleado; ...
flux=fopen(''...'',''r'');
i=fwrite(%empleado, sizeof(struct datos), 1, flux);
/*un elemento tamaño sizeof(struct datos) es escrito en el stream flux*/
i=fwrite(tab, sizeof(int), 1000, flux);
/*1000 elementos tamaño sizeof(int) son escritos en el stream flux*/
}
se lee un elemento de tamaño sizeof(struct datos) del stream flux y la información
while ( !feof(flux) ) {
fread(&empleado, sizeof(datos), 1, flux);

...
}
Uso de ftell() y fseek()

int fseek(FILE *stream, long int offser,, int whence)
SEEK CUR: valor actual indicador posici'on archivo;
SEEK SET: principio del archivo;
SEEK END: fin de archvio;
int ftell(FILE *stream)
Ejemplo uso:
char nombre[20], direc[60];
int pos;
FILE *base = fopen(''datitos'',''w+'');
for( i=0; ;i+=80)
{
fseek(base, i, SEEK SET);
pos = ftell(base);
fread(nombre, 20, 1, base);
fread(direc, 60, 1, base);
printf(''Nombre:%s, direc:%s, pos. archivo:%d \n'',nombre,direc,pos);
if(feof(base) )
break;
}
.
Ejemplos:
/* Detección de un fin de archivo */
#include <stdio.h>
#define PAR 100
main()
{
char Non[PAR];
char archivo[20];
FILE *fp;
puts("Introduce el nombre del archivo:");
gets(archivo); /* Abre el archivo para lectura */
if((fp = fopen(archivo, "r")) == NULL)
{
fprintf(stderr, "error abriendo el archivo.");
return 0;
}
/* Si no ha llegado al fin de archivo lee una línea y la despliega */
while(!feof(fp))
{
fgets(Non,PAR,fp);
printf("%s",Non);
} fclose(fp);
}
/* Copia de un archivo */

#include <stdio.h>
int copiaarchivo(char *nombrex, char *nombrey);
void main()
{
char Origen[100], Destino[100];
puts("Introduce el nombre del archivo origen:");
gets(Origen);
puts("Introduce el nombre del archivo destino:");
gets(Destino);
/* Abre el archivo para lectura */

if((copiaarchivo(Origen,Destino))== 0)
puts("Copia la operación:");
else
fprintf(stderr, "error al copiar:");
}
int copiaarchivo(char *nombrex, char *nombrey)
{
FILE *fx, *fy; int c;
/* Abre archivo fuente para lectura en modo binario */
if((fx =fopen(nombrex,"rb")) == NULL)
return -1;
/* Abre archivo fuente para escritura en modo binario */
if((fy= fopen(nombrey,"wb")) == NULL) {
fclose(fx);
return -1;
}
/* Lee un byte a la vez de la fuente */
/* Si no ha llegado al fín de archivo */
/* Escribe el byte al destino */
while(1) {
c = fgetc(fx);
if(!feof(fx))
fputc(c,fy);
else
break;
}
fclose(fy);
fclose(fx);
return 0;
}
/* Programa de nombres archivos temporales */

#include <stdio.h>
int copiaarchivo(char *nombrex, char *nombrey);
main()
{
char memoria[100], *c;
/* Se obtiene un nombre en en buffer dedinido */
tmpnam(memoria);

c = tmpnam(NULL);
/* Despliega nombres */
printf("Nombre temporal 1: %s",memoria);
printf("Nombre temporal 2: %s",c);
return 0;
} /*Este programa sólo genera e imprime los nombres temporales */
/* Programa que Calcula la función sen(x) por interpolación a partir de una tabla */
/* fichero interpol.c */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define PI 3.14159265358979
main()
{
double vector[91];
int x1, x2;
double y1, y2;
double x, y, a, b, radianes;
FILE *fi;
int i;
fi = fopen("tabla.d", "r");
for (i=0; i <= 90; i++)
fscanf(fi, " %lf", &vector[i]);
printf("Este programa calcula el valor del seno de un ángulo\n");
printf("por interpolación entre dos valores.\n");
printf("\nIntroduzca el valor del ángulo en grados:\n");
printf("valor: ");
scanf("%lf", &x);
printf("\n");
/* Valores entre los que interpolar */
x1 = (int)x;
x2 = x1 + 1;
y1 = vector[x1];
y2 = vector[x2];
/* Cálculo del valor interpolado */
a = (y2 - y1)/(x2 - x1);
b = (y1*x2 - y2*x1)/(x2 - x1);
y = a*x + b;
printf("El valor del seno de %6.2lf es %18.15lf.\n", x, y);
radianes = x*PI/180.0;
printf("%s%6.2lf es %18.15lf%s",
"El valor del seno de ", x,
sin(radianes), ", calculado con math.h");
}

.

CAPITULOSMOD

Cargado por

Información del documento

Descripción original:

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

CAPITULOSMOD

Cargado por

Copyright:

Formatos disponibles

CAPITULO 1

CARACTERÍSTICAS DE LAS COMPUTADORAS

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 2

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 3

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 4

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 5

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 6

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 7

LENGUAJES DE ALTO NIVEL

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 8

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 9

ESQUEMA ESTRUCTURAL DE UNA COMPUTADORA

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 10

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 11

El algoritmo debe tener las siguientes características:

Debe tener 5 partes:

METODOLOGÍA DE SOLUCIÓN DE PROBLEMAS

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 12

2. Planteamiento de alternativas de solución

3. Elección de una alternativa

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 13

SISTEMA NUMÉRICO DECIMAL

3 × 106 + 0 × 105 + 9 × 104+ 8 × 103 + 3 × 102 + 2 × 101+ 3 × 100, o 3 × 1

SISTEMA NUMERICO BINARIO (Lenguaje maquina).

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 14

La palabra bit se forma del acrónimo binary digit (dígito binario)

El lenguaje maquina se interpreta mediante pulsoa electrónicos Altos = 1 y bajos =0

SISTEMA NUMÉRICO OCTAL

SISTEMA NUMÉRICO HEXADCIMTAL

CONVERSIONES DE SISTEMAS NUMÉRICOS

CONVERSIÓN DE DECIMAL A BINARIO.

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 15

CONVERSIÓN DE BINARIO A DECIMAL

211 x 1+210 x 1+29 x 1 +28 x 0+27 x 0+26 x 1+25 x 0 + 24 x 1 + 23 x 0 + 22 x 1 +21 x 1 + 20 x 0

CONVERSIÓN DE BINARIO A DECIMAL

65536+32768+0+8192+0+2048+1024+0+ 256+128+0+32+16+0+4+2+1 = 11000710

CONVERSIÓN DE DECIMAL A OCTAL

82 x 5 + 81 x 3 + 80 x 2 = 64x5 + 8x3 + 1x2 = 320 + 24 + 2 = 34610

CONVERSIÓN DE BINARIO A OCTAL

CONVERSIÓN DE DECIMAL A HEXADECIMAL

CONVERSIÓN DE HEXADECIMAL A DECIMAL

162x10 + 161x11 + 160x12 = 256x10 + 16x11 + 1x12 = 2560 + 176 + 12 = 274810

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 17

OCTAL 11110101011101110110101012 = ( ? )8 = 1725673258

/*Programa que convierte un numero decimal a binario ,octal y hexadecimal utilizando la

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 18

Decimal Binario Octal Hexadecimal

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 19

BYTE: es una colección o paquete de 8 bits y representa un carácter.

La palabra bit se forma del acrónimo binary digit

Decimal Binario Lenguaje maquina Texto

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 20

CÓDIGO ASCII NORMAL(0 a 127 BYTES)

DecHexSímbolo DecHexSímbolo DecHexSímbolo Dec Hex Símbolo

CÓDIGO ASCII EXTENDIDO(128 a 255 BYTES)

El código ASCII extendido(128 al 255 bytes), se asignan a conjuntos de caracteres que

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 22

COMPUERTA LÓGICA NOT (Inversora o de negación)

0= 1y 1=0 La expresión 0 se lee cero negado es igual a 1 y viceversa

A= A Esta expresión se lee A doble negada es igual a A

COMPUERTA LÓGICA AND ( y ) ( Todo o nada)

APUNTES DE PROGRAMACIÓN EN C AUTOR: ING. JORGE LUIS RIVERA HERNÁNDEZ 09 23

/Lee un numero entero y determina si es par o impar/

/programa para calcular el factorial de un entero n /

/Aplicación de arreglos unidimensionales/