PROGRAMACIN BSICA

PROGRAMACIN BSICA

MANUEL JOSUE ESCOBAR CRISTIANI

RED TERCER MILENIO

AVISO LEGAL
Derechos Reservados 2012, por RED TERCER MILENIO S.C.
Viveros de Ass 96, Col. Viveros de la Loma, Tlalnepantla, C.P. 54080, Estado de Mxico.
Prohibida la reproduccin parcial o total por cualquier medio, sin la autorizacin por escrito del titular de
los derechos.
Datos para catalogacin bibliogrfica
Manuel Josu Escobar Cristiani
Programacin bsica
ISBN 978-607-733-168-1
Primera edicin: 2012

DIRECTORIO

Brbara Jean Mair Rowberry

Directora General

Jess Andrs Carranza Castellanos

Director Corporativo de Administracin

Rafael Campos Hernndez

Director Acadmico Corporativo

Hctor Ral Gutirrez Zamora Ferreira

Director Corporativo de Finanzas
Ximena Montes Edgar
Directora Corporativo de Expansin y Proyectos

NDICE
INTRODUCCIN.............................................................................................................................. 7
Mapa Conceptual ....................................................................................................................... 8
UNIDAD 1 ....................................................................................................................................... 9
CONCEPTOS BSICOS DE PROGRAMACIN................................................................................... 9
OBJETIVO: .................................................................................................................................. 9
Mapa Conceptual Unidad 1 ..................................................................................................... 10
Introduccin ..................................................................................................................... 11
1.1 Orgenes del lenguaje C ........................................................................................ 122
1.2 UNIX y el lenguaje C .............................................................................................. 133
1.3 Lenguajes de mquina, lenguajes ensambladores y lenguajes de alto nivel ............. 13
1.4 Compilacin y Ligado ................................................................................................. 17
1.5 El entorno integrado de desarrollo (IDE) ................................................................... 18
1.6 Estructura de un Programa en C ............................................................................. 20
1.7 Mi primer programa en C ....................................................................................... 21
Autoevaluacin: ....................................................................................................................... 25
UNIDAD 2 ................................................................................................................................... 266
TIPOS DE DATOS SIMPLES ............................................................................................................ 26
OBJETIVO.................................................................................................................................. 26
Mapa Conceptual Unidad 2 ..................................................................................................... 27
Introduccin ..................................................................................................................... 28
2.1 Tipos de datos simples ............................................................................................... 29
2.2 Declaraciones de Variables ........................................................................................ 29
2.3 Clases de almacenamiento ........................................................................................ 30
2.4 Sentencias de asignacin ......................................................................................... 311

3
2.5 Definicin de Constantes ......................................................................................... 322
2.6 Operadores .............................................................................................................. 333
2.6.1 Operadores aritmticos .......................................................................................... 34
2.6.2 Operadores de relacin y lgicos .......................................................................... 344
2.6.3 Conversiones de tipo ............................................................................................ 355
2.6.4 Operadores de incremento y decremento ............................................................. 37
2.6.5 Operadores para manejo de bits ............................................................................ 38
2.7 Procedimientos definidos de entrada / salida estndar ............................................ 39
Autoevaluacin: ....................................................................................................................... 42
UNIDAD 3 ..................................................................................................................................... 43
FUNCIONES Y LA ESTRUCTURA DEL PROGRAMA ......................................................................... 43
OBJETIVO: ................................................................................................................................ 43
Mapa Conceptual Unidad 3 ..................................................................................................... 44
Introduccin ..................................................................................................................... 45
3.1 Definicin de funcin ................................................................................................. 45
3.2 Llamada de una funcin ............................................................................................. 45
3.3 Funciones que regresan valores no enteros .............................................................. 46
3.4 Argumentos, llamada de una funcin por valor ........................................................ 47
3.5 Paso de parmetros de una funcin .......................................................................... 47
3.6 Variables..................................................................................................................... 47
3.6.1 Variables externas ................................................................................................. 488
3.6.2 Variables Estticas................................................................................................... 48
3.6.3 Variables registro .................................................................................................... 48
3.7 Funciones predefinidas en C ................................................................................... 48
3.8 Recursividad ............................................................................................................. 499
Autoevaluacin: ....................................................................................................................... 51

4
UNIDAD 4 ..................................................................................................................................... 52
ESTRUCTURAS DE CONTROL DE FLUJO ........................................................................................ 52
OBJETIVO: ................................................................................................................................ 52
Mapa Conceptual Unidad 4 ..................................................................................................... 53
Introduccin ................................................................................................................... 544
4.1 Proposiciones y bloques............................................................................................. 55
4.2 Sentencias Condicionales ........................................................................................... 57
4.2.1 If Else ..................................................................................................................... 577
4.2.2 Else If ....................................................................................................................... 60
4.2.3 Switch ...................................................................................................................... 61
4.3 Ciclos y bucles ............................................................................................................ 63
4.3.1 While y For .............................................................................................................. 63
4.3.2 Do While.................................................................................................................. 64
4.4 Break y Continue ........................................................................................................ 64
4.5 Etiquetas y goto ......................................................................................................... 65
Autoevaluacin: ....................................................................................................................... 67
UNIDAD 5 ..................................................................................................................................... 68
TIPOS DE DATOS ESTRUCTURADOS ............................................................................................. 68
OBJETIVO: ................................................................................................................................ 68
Mapa Conceptual Unidad 5 ..................................................................................................... 69
Introduccin ..................................................................................................................... 70
5.1 Arreglos. ..................................................................................................................... 71
5.2 Estructuras. ................................................................................................................ 73
5.2.1 Conceptos bsicos de estructuras. ......................................................................... 73
5.2.2 Estructuras y funciones. .......................................................................................... 75
5.2.3 Arreglos de estructuras. .......................................................................................... 75

5
5.2.4 Apuntadores a estructuras. .................................................................................... 76
5.2.5 Estructuras autorreferenciadas. ............................................................................. 79
5.3 Uniones ...................................................................................................................... 81
5.4 Campos de bits. .......................................................................................................... 81
Autoevaluacin: ....................................................................................................................... 84
UNIDAD 6 ..................................................................................................................................... 85
APUNTADORES............................................................................................................................. 85
OBJETIVO: ................................................................................................................................ 85
Mapa Conceptual Unidad 6 ..................................................................................................... 86
Introduccin ..................................................................................................................... 87
6.1 Definicin de Apuntadores. ....................................................................................... 88
6.2 Operacin de Apuntadores. ....................................................................................... 89
6.3 Apuntadores y Arreglos. ............................................................................................ 90
6.4 Aritmtica de direcciones. ......................................................................................... 93
6.5 Apuntadores a caracteres y funciones. ...................................................................... 93
6.6 Asignacin dinmica de memoria. ............................................................................. 96
Autoevaluacin: ..................................................................................................................... 101
UNIDAD 7 ................................................................................................................................... 102
ARCHIVOS Y ENTRADA / SALIDA ................................................................................................ 102
OBJETIVO: .............................................................................................................................. 102
Mapa Conceptual Unidad 7 ................................................................................................... 103
Introduccin ................................................................................................................... 104
7.1 Descriptores de archivos. ......................................................................................... 105
7.2 E/S de bajo nivel: read y write. ................................................................................ 106
7.3 E/S por consola: getchar( ) y putchar( ), gets( ) y puts( ). ........................................ 107
7.4 E/S por consola con formato printf( ) y scanf( ). ...................................................... 109

6
7.5 Manejo de archivos. ................................................................................................. 113
7.5.1 Open ...................................................................................................................... 114
7.5.2 Creat ...................................................................................................................... 114
7.5.3 Close ...................................................................................................................... 117
7.5.4 Unlink .................................................................................................................... 117
7.5.5 Acceso aleatorio: Lseek ......................................................................................... 117
Autoevaluacin: ..................................................................................................................... 119
Bibliografa: ................................................................................................................................ 120
Glosario

121

INTRODUCCIN
Desde 1978, ao en que nace el lenguaje de programacin C el mundo de las
computadoras ha cambiado enormemente, las grandes computadoras de
entonces tienen menos recursos que un pequeo equipo personal moderno,
dentro del gran desarrollo de los sistemas de cmputo podemos mencionar que
una gran computadora de hace ms de 30 aos, ocupaba una habitacin de
ms de 30 metros cuadrados y contaba con las siguientes caractersticas:
memoria principal de 64,000 Bytes, sin gigas, megas o kilos, su nico
dispositivo de entrada era por medio de tarjetas de cartn perforadas, y todos
los resultados los arrojaba impresos en papel continuo en una impresora del
tamao de una lavadora moderna, su pequeo teclado y su monitor
monocromtico servan para que los grandes gurs de programacin pudieran
encender y apagar dicha computadora, sin embargo en estos 32 aos el
lenguaje de programacin C solo ha sufrido cambios muy modestos.
En 1983, el American National Standars Institute (ANSI) estableci un
comit cuyo propsito era el desarrollo de un estndar de lenguaje C que
fuera totalmente independiente al equipo de cmputo en el que se utilizara,
naciendo de esta forma el estndar ANSI del lenguaje C.
El objetivo principal de este libro es ensearle al alumno el lenguaje de
programacin C; para lograr este objetivo es muy importante, que durante el
curso, el alumno tenga acceso a un equipo con el compilador C y as aprender
mediante la programacin constante de ejemplos y proyectos.
Es por esta razn, que desde el captulo 1 presentamos nuestro primer
programa en C, para comprender mejor lo explicado en este libro.
Espero que al finalizar el libro el estudiante sea capaz de resolver problemas de
programacin mediante la utilizacin de este lenguaje de programacin.

MAPA CONCEPTUAL

Conceptos Bsicos de
programacin

Tipos de datos del

lenguaje C

Estructuras de control
de Flujo

Funciones y
estructura del
lenguaje C

Datos Estructurados

Entrada / Salida

Apuntadores

UNIDAD 1
CONCEPTOS BSICOS DE PROGRAMACIN
OBJETIVO:
Que el estudiante aprenda cmo naci el lenguaje de programacin C y su
importancia en el desarrollo de los sistemas de cmputo, as como algunos
conceptos bsicos, pero en extremo importantes, utilizados en la programacin
de sistemas

TEMARIO
1.1

ORGENES DEL LENGUAJE C

1.2

UNIX Y EL LENGUAJE C

1.3

LENGUAJES DE MQUINA, LENGUAJES ENSAMBLADORES Y

LENGUAJES DE ALTO NIVEL

1.4

COMPILACIN Y LIGADO

1.5

EL ENTORNO INTEGRADO DE DESARROLLO (IDE)

1.6

ESTRUCTURA DE UN PROGRAMA EN "C"

1.7

MI PRIMER PROGRAMA EN C

10

MAPA CONCEPTUAL
Conceptos Bsicos de
programacin

Orgenes del
lenguaje C

UNIX y el
lenguaje C

Compilacin
y Ligado

IDE

Estructura
de C

Tipos de Lenguajes
de Programacin

11

INTRODUCCIN
El lenguaje C fue desarrollado hace 32 aos, durante ms de 3 dcadas a
conservado su esencia sin sufrir grandes cambios, en este captulo se mostrar
la estructura de un programa escrito en C, como logramos que las
instrucciones escritas por los programadores lleguen a ser entendibles por las
computadora, es decir, convertir el cdigo a lenguaje de unos y ceros. Tambin
escribiremos nuestro primer programa en C para poder condensar lo
aprendido en un programa sencillo.

12

1.1 ORGENES DEL LENGUAJE C

C es un lenguaje de programacin de propsito general y de tecnologa
abierta, es decir no depende de la mquina ni del sistema operativo con el que
opere. Gran parte de los fundamentos de C provienen del lenguaje BCPL
(Basic Combined Programming Languaje o Lenguaje de Programacin Bsico
Combinado) que fu desarrollado por Martin Richards en la Universidad de
Cambridge en 1966.
C proporciona construcciones fundamentales de control de flujo, una
variedad de tipos de datos principalmente: caracteres, enteros y nmeros de
punto flotante, tambin integra el uso de funciones con paso de parmetros.
C se puede considerar un lenguaje de programacin de medio nivel,
con esto no queremos decir que es menos potente o menos importante que
otros lenguajes conocidos de alto nivel.
C tiene una estructura y funciones que lo acercan a los lenguajes
ensambladores, ya que es una representacin simblica del cdigo mquina, no
es muy grande, pero su funcionalidad es similar a los lenguajes de alto nivel,
combinando elementos propios de estos lenguajes.
Durante varios aos la definicin de C fue el manual de referencia de la
primera edicin de El lenguaje de programacin C, fue hasta 1983 cuando el
American National Standards Institute (ANSI) estableci un comit para
proporcionar una definicin de C, resultando, as, el estndar ANSI C1, este
estndar internacional tiene el propsito de garantizar la portabilidad de
programas desarrollados con el lenguaje de programacin C a travs de una
gran variedad de sistemas de procesamiento de datos, es decir hacerlo
completamente independiente al equipo de cmputo y al sistema operativo en

ISO/IEC 9899:1999 Programming languajes C

http://webstore.ansi.org/RecordDetail.aspx?sku=ISO/IEC+9899:1999

13

que sea utilizado, y est pensado para implementadores y programadores de

sistemas.

1.2 UNIX

Y EL LENGUAJE

Como se mencion en la introduccin, este lenguaje de programacin naci

hace 32 aos, es decir en 1978, C se desarroll, originalmente, para el sistema
operativo UNIX por Dennis Ritchie, quien fue el creador de este lenguaje de
programacin, lo implant, en un principio, en una computadora DEC (Digital
Equipment Corporation) PDP-1, es importante mencionar que el sistema
operativo, el compilador C y los programas de aplicacin de UNIX estn escritos
en C.
C en una primera instancia fue utilizado para la programacin de
Sistemas (programas que hacen que las computadoras sean capaces de
realizar algn trabajo til), esto se debi a que un programa desarrollado en C
puede ser tan veloz al ejecutarse como un programa desarrollado en lenguaje
ensamblador, aunque es ms sencilla la programacin en C en comparacin
con la programacin en lenguaje ensamblador. Su velocidad de ejecucin es
una de las principales caractersticas de este lenguaje.

1.3 L ENGUAJES

DE MQUINA , LENGUAJES ENSAMBLADO RES Y LENGUAJES DE

ALTO NIVEL

Los lenguajes de programacin, al igual que nuestros lenguajes habituales

como pueden ser: el espaol, el ingls, el italiano, etc., deben poseer una
estructura o sintaxis y un significado o semntica.
Por ejemplo, la lengua espaola integra una serie de reglas para poder
combinar palabras y con esto formar oraciones o frases que puedan ser
entendibles por cualquier persona que conozca dicha lengua. De igual manera

14

los lenguajes de computadoras establecen reglas muy claras para su correcto

uso.
Resumiendo: un lenguaje de programacin es un conjunto de reglas,
smbolos y palabras especiales que permiten construir un programa2
Existen centenares de lenguajes de programacin para computadoras,
cada uno de los cules puede tener diferentes versiones, as como ventajas y
desventajas. Con base en la cantidad de instrucciones requeridas por cada uno
de estos lenguajes para realizar una tarea especfica, se pueden clasificar en:
bajo nivel y alto nivel, adems los lenguajes de bajo nivel estn ms cercanos a
las mquinas y son difciles de entender por los programadores, en cambio, los
lenguajes de alto nivel son cercanos y entendibles para la gran mayora de los
programadores.
Como lenguajes de bajo nivel podemos citar:

lenguajes de mquina

lenguajes ensambladores.

Lenguaje de Mquina
Un lenguaje de mquina es el nico lenguaje que, realmente puede
entender una computadora, es un conjunto de reglas sintcticas, escritos
exclusivamente con un conjunto de unos y ceros, por ejemplo:
1000110010010001
1100011101010110
1100110110101101
Estos lenguajes son muy difciles de programar y de entender -solamente
programadores expertos y muy capacitados podran entenderlos- a la vez que
2

Metodologa de la Programacin Diagramas de flujo, algoritmos algoritmos y programacin

estructurada. Luis Joyas Aguilar. Mc Graw Hill

15

son muy largos, como fueron los primeros programas en aparecer se les
conoce como lenguaje de primera generacin.
Estos lenguajes son desarrollados para ser utilizados en una sola
mquina y en un solo procesador, aunque son entendibles para la mquina en
que fueron desarrollados es muy difcil ser entendido por los programadores.

Lenguaje ensamblador
Para ser ms sencillos de entender por los programadores se
desarrollaron los lenguajes ensambladores, son ms fciles de utilizar que el
lenguaje de mquina, y son nicos para un procesador en particular (Z80, 8080,
Pentium IV, etc.), utilizan smbolos para interpretar las instrucciones en lugar
de largas cadenas de 1 y 0

Por ejemplo:
LR 5,0
M 4,=F4
4,7

No entraremos en detalle de explicar las instrucciones de este tipo de

lenguajes, ya que solo aplicara para un procesador en particular, y se sale de
los objetivos de este libro.
Para muchos especialistas en la historia del software constituyen la
segunda generacin de los lenguajes de programacin

Lenguajes de Alto Nivel

16

Como podemos entender, existe el inters por el desarrollo de lenguajes de

programacin cada vez ms sencillos, con instrucciones que puedan leerse
con facilidad y de ser posible no dependan de la mquina ni del procesador
utilizados, que sirvan para el desarrollo de algoritmos para ejecutarse en la
mayora de los equipos de cmputo.
Una sola instruccin en un lenguaje de alto nivel supone varias
instrucciones en lenguaje de mquina.
Por ejemplo:

Z= X + Y / 2 + C*SEN(N)

puede equivaler, tal vez, a

centenares de instrucciones en lenguaje de mquina.

Compilador
C

Programa
fuente en C

Computadora

Programa Objeto o
de mquina

Figura 1) Proceso de creacin del cdigo de mquina a partir de un

lenguaje de alto nivel

Se conocen como Lenguajes de Tercera Generacin

Un Lenguaje de Alto nivel requiere de procesos intermedios (Compilacin
y Ligado) para poder ser entendido por una computadora, es decir para generar
el cdigo de mquina.
Actividad de aprendizaje
El estudiante deber investigar como compilar y ligar un programa
desarrollado en C en los equipos con que cuente la escuela, as mismo debe

17

comparar las instrucciones de compilacin y ligado por lo menos con otros 3

lenguajes de alto nivel.

1.4 C OMPILACIN

L IGADO

Como se mencion en el tema anterior para que un programa de alto nivel

pueda ser ejecutado en una computadora, es preciso realizar los procesos de
compilacin y ligado de dicho programa.
Compilacin: Proceso de verificar las instrucciones escritas en el
lenguaje de alto nivel para garantizar que no tenga errores de sintaxis, es decir
que no tenga un formato no vlido. Si al compilar el programa la computadora
regresa errores el programador debe revisarlos para tomar las correcciones
necesarias.
Un compilador lee el programa en su totalidad y lo convierte en cdigo
objeto, llamado tambin cdigo binario o de mquina.
Algunos compiladores detienen su ejecucin al encontrar el primer error,
otros en cambio analizan el programa en su totalidad y entregan una lista de
todos los errores encontrados, de esta manera se optimiza el tiempo de los
programadores.
En ocasiones aunque la compilacin sea exitosa, los programas no
muestran los resultados deseados, esto se debe a errores en la lgica de la
programacin, un ejemplo muy claro es la de dividir entre cero una cierta
cantidad, lo que ocasiona un error al momento de ejecutar el programa ya
compilado, durante el proceso de compilacin, si la instruccin est bien escrita,
este error no puede ser sealado.
Una vez que un programa de alto nivel se ha compilado es necesario
utilizar un proceso que lo una a todas las funciones del lenguaje o a otros
programas previamente desarrollados, a este proceso se le conoce como
Ligado.

18

Cdigos previamente
programados
C
Programa
fuente en C

Compilador
C

Ligador

Programa
Ejecutable

Figura 2) Proceso de creacin del programa ejecutable a partir de un

lenguaje de alto nivel

Recordemos que el cdigo fuente es el texto de un programa escrito por

los programadores y el programa ejecutable es el cdigo generado por la
compilacin y el ligado y es una secuencia de instrucciones escritas con unos y
ceros.
Cada vez que se realicen cambios en el programa fuente escrito en
lenguaje de alto nivel- ser necesario volver a compilar y a ligar dicho programa
para obtener as el nuevo cdigo ejecutable.

1.5 E L

ENTORNO INTEGRADO DE DESARROLLO

(IDE)

Un entorno de desarrollo integrado, IDE (por sus siglas en ingls: Integrated

Development Environment), es una aplicacin informtica compuesta por un
conjunto de herramientas de programacin, que permitan realizar todas las
fases de puesta a punto de un programa, esta aplicacin debe incluir: un editor
de cdigo, un compilador, un ligador, una interfaz grfica, etc. Tiene la finalidad
de hacer el trabajo de los programadores mucho ms sencillo englobando las
herramientas de desarrollo dentro del ambiente de cmputo del programador,
adems de permitir la programacin de aplicaciones de una manera rpida y
sencilla.

19

Puede dedicarse exclusivamente a un slo lenguaje de programacin o

bien, puede utilizarse para varios.
Los IDEs pueden ser aplicaciones por s solas o pueden ser parte de
aplicaciones existentes. Por ejemplo El lenguaje Visual Basic, puede ser usado
dentro de otras aplicaciones de Microsoft Office, con esto se logra escribir
sentencias Visual Basic en forma de macros para Microsoft Word, o Microsoft
Excel.
Los IDE proveen un marco de trabajo amigable para los programadores
en la mayora de los lenguajes de programacin tales como C, C++, Python,
Java, C#, Delphi, Visual Basic, etc.
Es posible que un mismo IDE pueda funcionar con varios lenguajes de
programacin.
Como ejemplos de IDE podemos citar:

Visual Basic, que es un entorno visual e interactivo.

Eclipse, al que mediante plugins se le puede aadir soporte de lenguajes

adicionales.

Dev-C++, es un Entorno Integrado de Desarrollo para el lenguaje de

programacin C/C++

IDE PHP

Principalmente un IDE debe incluir los siguientes componentes:

Editor de texto.

Compilador.

Intrprete, dependiendo del lenguaje de programacin utilizado los

intrpretes se utilizan en lugar de los compiladores.

Diversas herramientas de automatizacin.

Debbuger (depurador).

Posibilidad de ofrecer un sistema de control de versiones.

20

Interfaces grficas de usuario.

Actividad de aprendizaje
El estudiante deber investigar cual es el Entorno Integrado de

Desarrollo que ser utilizado durante el curso, investigar cules son sus
componentes principales y cmo pueden utilizar dichos componentes.

1.6 E STRUCTURA

DE UN

P ROGRAMA

EN

Un programa escrito en lenguaje C est compuesto por una o ms funciones.

Como sabemos, una funcin es un programa que realizar una tarea
determinada, por ejemplo, la funcin printf sirve para imprimir datos en la salida
estndar de C.
En el lenguaje de programacin C existe una funcin que debe estar
presente en todos los programas escritos en este lenguaje, sirve para marcar el
inicio y el fin de la ejecucin de cualquier programa realizado; esta es la funcin
principal, la primera que se ejecuta, a partir de ella se inician todas las
instrucciones que deban ser ejecutadas, es la funcin main. Su sintaxis es:
main()
{
<conjunto_de_instrucciones>
}

La funcin inicial de C main contiene el conjunto de instrucciones de un

programa, dichas instrucciones se ubican dentro de los caracteres abrir llave ({)
y cerrar llave (}).
Recordemos: los picoparntesis < > se utilizan para colocar dentro de
ellos una o ms instrucciones y, en este caso, no deben ser escritas como parte

21

del programa C, solo las hemos utilizado como una notacin, en cambio las
llaves { } indican el principio y el fin de una funcin escrita en C y deben ser
escritas en el programa.
Los parntesis "()" escritos despus de main sirven para indicar que el
identificador main es una funcin, y que no recibe argumentos, es importante
comprender que main no es una palabra reservada de C.
Dentro de las llaves podemos escribir todo nuestro programa, realizar
llamadas a otras funciones, ya sean escritas por el mismo programador o
almacenadas dentro de las libreras del lenguaje de programacin C.
Si se van a utilizar libreras del lenguaje de programacin, antes del
nombre de la funcin deben indicarse las libreras a utilizarse, por ejemplo:

#include <stdio.h>

Esta instruccin le indica al compilador C que incluya informacin de la

biblioteca estndar de entrada/salida (estndar input/output), es decir se incluir
un conjunto de funciones que proporcionan entrada y salida de informacin al
programa o funcin que lo requiera, esta biblioteca ha sido desarrollada como
parte del lenguaje de programacin C.

1.7 M I

PRIMER PROGRAMA EN

Para comprender mejor la estructura de un programa en C, y teniendo en

cuanta que la mejor forma de aprender un nuevo lenguaje de programacin es
escribiendo programas con l, escribiremos nuestro primer programa en C, el
objetivo de este programa es muy sencillo, imprimir las palabras:
Buenos dias amigos

22

Para lograr este objetivo se debe de escribir el siguiente programa en C:

#include <stdio.h>
main()
{
printf(Buenos das amigos\n);
}

Este sencillo programa nos sirve para comprender los puntos sealados
en el tema 1.6, donde aprendimos la estructura bsica de un programa en C y
nos prepara para entender mejor los siguientes captulos donde aprenderemos
las principales funciones existentes en el lenguaje C.
Para comprender mejor este programa daremos las siguientes
explicaciones:
Un programa en C est compuesto de funciones y variables.
Una funcin contiene proposiciones, las cules especifican todas las
operaciones de clculo que deben ser realizadas, estas son similares a las
subrutinas o procedimientos utilizados en otros lenguajes de programacin.
Las variables almacenan los valores utilizados durante los clculos.
Una funcin puede tener el nombre que el programador desee, pero main es
la funcin principal de un programa en C, cualquier programa escrito en C
comienza a ejecutarse al principio de esta funcin, por lo que cualquier
programa debe existir una funcin main en alguna parte de dicho programa.
Esta funcin principal llamar a otras funciones que la ayuden a realizar
su trabajo, algunas de estas funciones son de la biblioteca de C, y otras las
puede realizar usted mismo.

23

Una de las formas en que pueden comunicar datos entre las diversas
funciones es por medio de una lista de valores que proporciona la funcin que
llama, a la funcin que est invocando, esta lista de valores o argumentos se
ubican entre parntesis despus del nombre de la funcin.
En nuestro primer programa la funcin main() est definida para ser una
funcin que no espera argumentos, por lo que la lista entre parntesis est
vaca.
La primera lnea del programa:

#include <stdio.h>

le indica al

compilador C que incluya la biblioteca estndar de entrada/salida, con esta

lnea empiezan muchos de los programas escritos en lenguaje C.
Para una mejor comprensin de nuestro ejemplo explicaremos el
significado de cada una de las lneas escritas:

#include <stdio.h> Incluye informacin de la biblioteca estndar de E/S

main()

Definicin de la funcin main que no recibe argumentos

Todas las instrucciones de una funcin se encierran entre

llaves { }

printf(Buenos das amigos\n); Desde la funcin main se llama a la funcin

de biblioteca printf, la cual imprime la
secuencia de caracteres encerrada entre
comillas; \n representa el carcter lnea
nueva

24

ACTIVIDAD DE APRENDIZAJE

El estudiante deber escribir el programa, compilarlo, ligarlo para obtener

el objetivo deseado en los equipos de cmputo de la escuela, entregar al
profesor el programa impreso y los resultados obtenidos.
En los captulos siguientes iremos aprendiendo operaciones, estructuras,
funciones, argumentos, variables, etc., pero todos los programas que
realicemos deben cumplir con la estructura bsica descrita en este captulo.

25

AUTOEVALUACIN
1. Menciona las principales caractersticas del Lenguaje de Programacin C

Lenguaje de propsito general.

Tecnologa abierta, es decir no depende del equipo o del sistema

operativo.

Alta velocidad de ejecucin.

2. En qu consiste el proceso de Compilar un programa desarrollado en un

lenguaje de alto nivel?
Sirve para convertir el programa escrito en lenguaje de alto nivel a cdigo
de mquina (unos y ceros) entendible para la computadora, adems de
verificar la sintaxis del programa.
3. Qu instruccin del lenguaje de programacin C sirve para llamar la
biblioteca estndar de entrada/salida?
#include <stdio.h>
4. Cul es el nombre de la funcin principal, con la cul empieza y termina un
programa desarrollado con C?
Main
5. Entre qu smbolos deben escribirse todas las instrucciones a jecutarse en
una funcin desarrollada en C?
Todas las instrucciones de una funcin deben encerrarse entre llaves { }

26

UNIDAD 2
TIPOS DE DATOS SIMPLES
OBJETIVO
Que el estudiante aprenda los diferentes tipos de datos, como se declaran
variables, conozca el concepto de constantes y se familiarice con los diferentes
operadores

con

su

manejo,

por

ltimo

aprender

los

diferentes

procedimientos existentes en el lenguaje de programacin C.

Sugerimos recursos, actividades de aprendizaje y formas auto-evaluativas de
progresiva dificultad, estos elementos son flexibles y adaptables; por tanto, no
todos deben efectuarse, solo aquellos que el profesor estime necesarios para el
logro de los objetivos del curso. De esta manera adecuar este captulo, y el
libro en general a sus necesidades.

TEMARIO
2.1 TIPOS DE DATOS SIMPLES
2.2 DECLARACIONES DE VARIABLES
2.3 CLASES DE ALMACENAMIENTO
2.4 SENTENCIAS DE ASIGNACIN
2.5 DEFINICIN DE CONSTANTES
2.6 OPERADORES
2.6.1 OPERADORES ARITMTICOS
2.6.2 OPERADORES DE RELACIN Y LGICOS
2.6.3 CONVERSIONES DE TIPO
2.6.4 OPERADORES DE INCREMENTE Y DECREMENTO
2.6.5 OPERADORES PARA MANEJO DE BITS
2.7 PROCEDIMIENTOS DEFINIDOS DE ENTRADA/SALIDA ESTNDAR

27

MAPA CONCEPTUAL

Conceptos bsicos de
programacin

Tipos de datos
simples

Declaracin de
variables

Orgenes del
lenguaje C

Sentencias de asignacin y
definicin de Constantes

Operadores

E/S Estndar

Clases de
almacenamiento

28

INTRODUCCIN
El lenguaje C se desarroll para el manejo sencillo de datos, con variables,
constantes y operadores simples, si bien permite el manejo de informacin
numrica y alfanumrica, las operaciones son sencillas, dentro de este captulo
aprenderemos que las variables y las constantes son los objetos de datos
bsicos que se utilizan en un programa en C, para la utilizacin de los cules
se manejan:

Las declaraciones: muestran las variables que se van a utilizar, establecen

su tipo y en muchas ocasiones sus valores iniciales.

Operadores: indican que vamos a hacer con las variables y constantes.

Expresiones: combinan los datos (variables y constantes) y producen

nuevos valores.

29

2.1 TIPOS DE DATOS SIMPLES

En C existen los siguientes tipos de datos, los cules aplican tanto para
constantes como para variables:

char Un solo byte, contiene un carcter del conjunto de caracteres

empleado.

int

representa un nmero entero.

o Para este tipo de datos existen los calificadores: short y long, por
ejemplo:

short int nombre;

long int nombre;

float punto flotante de precisin normal

doubl punto flotante de precisin doble.

2.2 D ECLARACIONES

DE

V ARIABLES

Los nombres de variables se componen de letras y dgitos, tambin podemos

utilizar el guin medio -, pero siempre el primer carcter del nombre de una
variable debe ser una letra.
Las letras maysculas y minsculas son distintas, por lo que debemos tener
cuidado en el uso de letras maysculas para evitarnos errores en la
programacin, por ejemplo x y X son dos variables distintas.
Por convencin en C todas las variables usan letras minsculas y las
constantes simblicas usan letras maysculas. Los primeros 31 caracteres de
un nombre interno son significativos.

30

Existen palabras reservadas del lenguaje C como son if, else, char, int, etc.
que no pueden utilizarse como nombres de variables.
Es muy conveniente que se utilicen nombres que tengan que ver con el
propsito de la variable.
Todas las variables deben de ser declaradas antes de ser utilizadas, es decir
para que podamos utilizar una variable es preciso utilizar una declaracin
previamente, la declaracin especifica un tipo y contiene una lista de una o ms
variables del tipo indicado, las declaraciones deben tener la siguiente sintaxis:
<tipo> <nombre1, nombre2,>;
Donde <tipo> toma cualquiera de los valores expresados en el tema 2.1, como
ejemplos podemos citar las siguientes declaraciones:
int num, alfa, variable;
char nombre, apellido, n;
float x;
Como se observa en los ejemplos anteriores todas las declaraciones finalizan
con el smbolo ;

2.3 C LASES

DE ALMACENAMIE NTO

Como mencionamos anteriormente en C existen los siguientes tipos de

variables:
char Un solo byte, contiene un carcter del conjunto de caracteres empleado
8 bits.
int

representa un nmero entero.

31

Para este tipo de datos existen los calificadores: short y long, por
ejemplo:
short int nombre;

entero de 16 bits como mximo

long int nombre;

entero de 32 bits como mximo

por lo que un int es de 16 o de 32 bits, pero cada compilador puede

seleccionar los tamaos de acuerdo a su hardware
float punto flotante de precisin normal.
double

punto flotante de precisin doble.

Existen tambin los calificadores signed y unsigned, que se utilizan tanto para
datos tipo char como para datos int, los nmeros unsigned son siempre
positivos o cero.

ACTIVIDAD DE APRENDIZAJE
El estudiante deber investigar, para el equipo de cmputo y el compilador
utilizados en clase, los tamaos disponibles para todos los tipos de datos
sealados, incluyendo el uso de los calificadores short, long, unsigned y signed.

2.4 S ENTENCIAS

DE ASIGNAC IN

En el lenguaje de programacin C, la asignacin de valores se da mediante el

smbolo =, como podemos ver en las expresiones siguientes:
i = j +3
z = n*5
El resultado o valor de la expresin del lado derecho del sbolo = se le
asignar a la variable ubicada en su lado izquierdo.

32

Expresiones donde la variable del lado izquierdo se repite inmediatamente en el

lado derecho, como en la expresin:
i=i+2
Puede ser escrita en la forma compacta
i += 2
El operador += se llama operador de asignacin.
La mayora de los operadores binarios, es decir que tienen un operando
derecho y uno izquierdo, tienen un correspondiente operador de asignacin op
=, donde op es uno de los siguientes smbolos:
+-*/%<<>>
2.5 D EFINICIN

DE

C ONSTANTES

Una constante entera es un int, una constante long se escribe con una l o L al
final de la constante, un entero demasiado grande para caber dentro de un valor
int se toma como long, si la constante no tiene signo se escribe con una u o U y
con una ul o UL se escribe una constante long sin signo.
El valor de un entero puede especificarse en forma octal o hexadecimal en lugar
de la forma decimal. Un 0 (cero) al principio de una constante entera significa
octal; un 0x o 0X al principio significa hexadecimal.
Ejemplo
Decimal

31

Octal

031

Hexadecimal

0X1F

Estas pueden ser seguidas por L para convertirlas en long y U para convertirlas
en unsigned (sin signo).

33

Por ejemplo: 0XFUL es una constante sin signo long con valor de F
hexadecimal o 15 en decimal.
Las constante de punto flotante contienen punto decimal (123.45) o un
exponente (le-2), o ambos, su tipo es double, los sufijos f o F indican una
constante float; l o L indican un long double.
Una constante de tipo carcter se escribe dentro de apstrofos .
El valor de una constante de carcter es el valor numrico del carcter
dentro el conjunto de caracteres de la mquina
Por ejemplo x, 0 este ltimo ejemplo el valor de 0 en el conjunto de
caracteres ASCII es 48 no equivale al entero 0

2.6 O PERADORES
Los operadores nos permiten el manejo de operandos para obtener nuevos
valores, generalmente son binarios, es decir requieren 2 operandos, pero
tambin existen en C operadores que solo utilizan un operando.
Como ejemplo de operadores podemos utilizar los operadores de asignacin
como +=
i += 2
En esta expresin se incrementa en 2 el valor de i y es equivalente a la
expresin:
i=i+2
La mayora de los operadores binarios tienen un correspondiente operador de
asignacin, op= donde op es uno de los siguientes operadores binarios:
+ - * / % << >> & ^ |

34

Veamos el siguiente ejemplo: si exp1 y exp2 son dos expresiones

exp1 op= exp2
Es equivalente a:
expr1 = (expr1) op (expr2)
La expresin:
Significa:

x *= y+1

x= x*(y+1)

2.6.1 Operadores aritmticos

Los operadores aritmticos binarios, es decir que llevan 2 operandos, son:
+, -, *, / y el operador mdulo %
Este ltimo produce el residuo de una divisin, por ejemplo:
x % y produce el residuo cuando x se divide entre y.
Por lo que da el valor cero cuando y divide a x exactamente, no se aplica a
operandos float o double.

2.6.2 Operadores de relacin y lgicos

Los operadores de relacin son:
>

>=

<

<=

Todos tienen la misma prioridad, bajo estos operandos en prioridad estn los
operadores de igualdad:
==

35

Estos operadores (de relacin) tienen prioridad inferior a los operadores

aritmticos, es decir primeramente se realiza la operacin aritmtica y luego la
operacin de relacin, por ejemplo, la operacin:
i<a1
es equivalente a la siguiente operacin:
i < (a 1).
Los operadores lgicos son:
&&

||

Todas las expresiones que usan estos operadores se evalan de izquierda a

derecha, detenindose la evaluacin tan pronto como se obtenga el resultado
verdadero o falso

ACTIVIDAD DE APRENDIZAJE
El estudiante deber realizar un programa sencillo donde utilice los diferentes
operadores y validar la preferencia que ellos tienen en el clculo de los
resultados, el maestro puede dejar un programa en particular a realizar o puede
dejar la opcin abierta para que los estudiantes decidan qu problema resolver.

2.6.3 Conversiones de tipo

Cuando un operador tiene diferentes tipos de operandos, estos se convierten a
un tipo comn de acuerdo a las siguientes reglas:
Las nicas conversiones automticas son las que se convierten un operando
angosto en uno amplio, sin prdida de informacin, por ejemplo convertir un
entero en punto flotante (f + i).

36

Las expresiones que no tienen sentido no son permitidas.

Las expresiones que podran perder informacin, por ejemplo de un tipo punto
flotante a un entero, pueden producir una advertencia pero son permitidas.
Un char, como es un entero pequeo pueden ser utilizadas libremente en
expresiones aritmticas.
A manera de ejemplo podemos analizar la siguiente funcin, que hemos
llamado atoi, convierte una cadena de dgitos en su equivalente numrico.3

/* atoi: convierte s en entero */

int atoi (char s[])
{
int i, n;
n=0;
for (I = 0; s[i] >= 0 && s[i] <= 9; ++i)
n = 10*n+(s[i]-0);
return n;
}

ACTIVIDAD DE APRENDIZAJE
El estudiante deber referirse al libro El lenguaje de programacin C autores
Brian W. Kernighan y Dennis M. Ritchie editorial Pearson Educacin , pgina 47
para analizar cada una de las expresiones utilizadas en este ejercicio y las
entregar al profesor.

Ejemplo tomado del libro: El Lenguaje de Programacin C de Brian W. Kernighan, Dennis M.

Ritchie

37

En resumen, y en forma general las siguientes reglas bastarn:

Si cualquiera de los operandos es long doubl, el otro se convierte en

long doubl.

Si cualquiera de los operandos es doubl, el otro se convierte en doubl.

Si cualquier operando es float, el otro se convierte a float.

Los tipos chart y short se convierten a int.

Si cualquier operando es long el otro se convierte a long.

2.6.4 Operadores de incremento y decremento

En el lenguaje de programacin C se introducen dos operadores poco
comunes que incrementan y decrementan variables:
++ suma 1 a su operando.
-- resta 1 a su operando
Ejemplo: n++
Se pueden utilizar antes o despus del operando, pero si se utiliza antes (++n)
incrementa el operando antes que su valor se utilice, y se se emplea despus
(n++) incrementa n despus de incrementar su valor.
Ejemplo:
Si n=5
X=n++

asigna 5 a la variable x

X=++n

asigna 6 a la variable x

38

2.6.5 Operadores para manejo de bits

Existen los siguientes 6 operadores para el manejo de bits:
&

AND de bits

OR inclusivo de bits.

OR exclusivo de bits.

<<

Corrimiento a la izquierda.

>>

Corrimiento a la derecha.

Complemento a uno.

Para que la prioridad de los diferentes operadores utilizados en C nos quede

ms clara, analice la siguiente tabla:
Mxima

()

[]

--

++ -- -(type) *& size of

* / %
+ << >>
< <= > >=
== =
&
^
|
&&
||

39

A?:
Mnima

= += -= *= /=

2.7 P ROCEDIMIENTOS

DEFINI DOS DE ENTRADA

SALIDA ESTNDAR

Recuerde que en el lenguaje C no existen funciones construidas e

incorporadas para realizar operaciones de E/S, pero estas funciones si se
encuentran en la librera estndar de C.
En este captulo analizaremos las siguientes funciones:
getchar()

lee un carcter desde la entrada estndar (normalmente

teclado.

putchar()

imprime un carcter por la salida estndar (normalmente la

pantalla.

gets()

Lee una cadena desde el teclado

puts()

Escribe una cadena en la pantalla

printf()

produce salida formateada.

scanf()

produce entrada formateada.

Con estas dos ltimas funciones se puede formatear la informacin.

En C toda E/S es orientada a carcter, esto aplica para la lectura y
escritura por consola (teclado y pantalla), y para las funciones de archivos en
disco, es decir en C uno puede leer y escribir bytes.
La entrada y salida por consola se refiere a las operaciones sobre el
teclado y la pantalla de la computadora.
El mecanismo de entrada ms simple es el de leer un carcter a la vez
de la entrada estndar, normalmente el teclado con la funcin getchar:

40

int getchar(void)
getchar regresa el siguiente carcter de la entrada cada vez que es invocada o
EOF cuando encuentra el fin de archivo. La constante simblica EOF (End of
File) est definida en <stdio.h> y su valor tpicamente es -1.
Un archivo puede tomar el lugar del teclado empleando la convencin <
para re direccionamiento de entrada
La funcin putchar

escribir un carcter en la salida estndar,

normalmente la pantalla de la computadora.

Las funciones gets() y puts(), son utilizadas para leer e imprimir cadenas
de caracteres por consola, gets() devuelve una cadena de caracteres terminada
con el carcter nulo, permite corregir errores en la cadena mediante la tecla
backspace antes de oprimir la tecla enter.
puts() escribe el argumento de cadena sobre la pantalla reconoce los cdigos
de barra invertida, al igual que printf, como \n para cambio de lnea.
La funcin printf permite salidas formateadas y tiene la siguiente sintaxis:
Printf(cadena de control , lista de argumentos);
Donde la cadena de control consta de dos tipos de elementos, el primero
est formado por los caracteres que se imprimirn en la salida estndar y el
segundo contiene comandos de formato, que muestra la forma en se que se
mostrarn en la salida estndar los argumentos siguientes, debe haber el
mismo nmero de comandos de formato que de argumentos
Los cdigos de control de formato de printf son:
Cdigo de printf()
%c
%d
%e
%f

formato
un nico carcter.
Decimal.
Notacin cientfica.
Coma flotante decimal.

41

%g
%o
%s
%u
%x

Utiliza %e o %f, la que sea mas corta.

Octal.
Cadena de caracteres.
Decimal sin signo.
Hexadecimal.

Estos cdigos de control de de formato pueden incluir modificadores para

especificar: anchura de campo, nmero de decinmales y un indicador que
ajuste a la izquierda. Un entero situado entre el signo % y el comando de
formato acta como indicador de anchura mnima del campo
Ejemplos de salidas formateadas con printf()
Sentencia printf()

Salida

(%-5.2f,123.234)

123.23

ACTIVIDAD DE APRENDIZAJE
El estudiante deber realizar el siguiente programa en C, el cul tomar
caracteres desde el teclado y los imprimir en pantalla, cambiando las
maysculas por minsculas y viceversa, para finalizar el programa se debe
pulsar un punto.
Main () /* cambia maysculas por minsculas y viceversa*/
{
char ch;
do {
ch=getchar();
if (islower(ch)) putchar(toupper(ch));
else putchar(tolower(ch));
}while (ch !=.; /* use el punto para parar el programa*/
}
El alumno buscar la definicin de las funciones islower, toupper y
tolower para discutirlas en clase.
Nota las funciones do-while, if-else se estudiarn a lo largo de este curso.

42

AUTOEVALUACIN
1. Menciona los operadores que maneja C

Operadores aritmticos.

Operadores lgicos y de relacin.

Operadores de manejo de bits.

Operadores de asignacin.

2. Menciona los diferentes tipos de variables que se manejan en C.

char
int.
short int
long int
float
double.
3. Cul es el smbolo que se utiliza para asignar un valor a una variable?
=
4. Menciona un ejemplo de operador de asignacin
+=
5. Menciona un operador de incremento y uno de decremento
++

--

43

UNIDAD 3
FUNCIONES Y LA ESTRUCTURA DEL PROGRAMA
OBJETIVO:
Que el estudiante aprenda qu son las funciones y cmo utilizarlas, cmo pasar
y recibir informacin a y desde una funcin, conozca las diferentes variables
que existen en C y conozca el concepto de recursividad.

TEMARIO
3.1 DEFINICION DE FUNCION.
3.2 LLAMADA DE UNA FUNCION.
3.3 FUNCIONES QUE REGRESAN VALORES NO ENTEROS.
3.4 ARGUMENTOS, LLAMADA DE UNA FUNCIN POR VALOR.
3.5 PASO DE PARAMETROS DE UNA FUNCION.
3.6 VARIABLES.
3.6.1 VARIABLES EXTERNAS.
3.6.2 VARIABLES ESTATICAS.
3.6.3 VARIABLES REGISTRO.
3.7 FUNCIONES PREDEFINIDAS EN C.
3.8 RECURSIVIDAD.

44

MAPA CONCEPTUAL
Definicin de funcin

Llamada de una
funcin

Valores de las
funciones

Paso de
parmetros

Variables

Funciones
predefinidas

Recursividad

Argumentos y
llamadas a
funciones

45

INTRODUCCIN
Las funciones nos sirven para dividir tareas grandes en tareas ms pequeas,
nos dan la posibilidad de construir sobre los programas que otros han hecho y
utilizarlos para nuevas soluciones en lugar desde comenzar desde cero.
El lenguaje C se dise para que las funciones fueran eficientes y muy fciles
de utilizar normalmente los programas que se escriben en C se componen de
muchas funciones pequeas en lugar de solo algunas grandes.

3.1 D EFINICIN

DE FUNCIN

Las funciones son bloques con los que se constituyen programas en lenguaje
C y en ellas se llevan a cabo las funciones del programa.
Una vez que una funcin ha sido escrita, compilada, ligada y depurada puede
utilizarse una y otra vez desde cualquier otro programa

3.2 L LAMADA

DE UNA FUNCIN

El formato general de una funcin en C es el siguiente:

nombre_funcion (lista de parmetros)
declaraciones de parmetros;
{
cuerpo de la funcin;
}
El nmero de parmetros pueden ser cero, en este caso no es necesaria
las seccin de declaraciones.

46

Todas las funciones devuelven por lo menos un valor, este valor puede
estas explcitamente especificado con la palabra return, o bien puede ser cero si
no se especifica ningn otro valor. Por default todas las funciones devolvern
valores enteros pero se pueden especificar otro tipo de valores.
Una funcin puede ser utilizada dentro del cuerpo de una expresin,
debido a que cada funcin devuelve un valor, como ejemplo de esto
mencionamos las siguientes expresiones todas validad en C :
x= potencia (y);
if ( max(x,y) > 100) printf(mayor que);

3.3 F UNCIONES

QUE REGRESA N VALORES NO ENTEROS

El valor entero es el tipo de dato que por default se devuelven en funciones de

C, en ocasiones es necesario que devuelvan otro tipo de datos, por esto las
funciones se pueden declarar para que devuelvan cualquier tipo de datos
incluidos en C. La forma de la declaracin es similar al de declaracin de
variables, se utilizan el mismo tipo de especificadores, precediento al nombre
de la funcin.
El formato general de una declaracin de funcin es:
Especificador_tipo nombre_funcin(lista de parmetros)
Declaraciones de parmetros;
{
Expresiones (sentencias de la funcin);
}
El especificador de tipo le indica al compilador C el tipo de dato que va
a devolver la funcin.

47

Cuando se utiliza un valor devuelto que no sea entero se tiene que hacer
una segunda cosa: La rutina que llam a la funcin tiene que saber el tipo de
dato que devolver la funcin, por lo que debemos declarar la funcin dentro de
la rutina de llamada.

3.4 A RGUMENTOS ,

LLAMADA DE UNA FUNCI N POR VALOR

Generalmente existe dos formas en que pueden pasarse los argumentos a las
funciones: La primera se denomina llamada por valor, este mtodo copia el
valar de cada uno de los argumentos en los parmetros formales de la funcin,
la segunda forma se conoce como llamada por referencia con este mtodo, la
direccin de cada argumento se copia los parmetros de la funcin, es decir los
cambios hechos en el parmetro afectaran a la variable utilizada para llamar a
la funcin.
Las funciones C utilizan la llamada por valor, esto significa que no se
pueden alterar las variables utilizadas para llamar a la funcin esta es la forma
general.

3.5 P ASO

DE PARMETROS DE UNA FUNCIN

Los parmetros dentro de una funcin C se pasan despus del nombre de la

funcin y deben ser encerrados entre parntesis () y a continuacin del nombre
se deben declarar los parmetros de la funcin.

3.6 V ARIABLES
Una variable local es dinmica; se crea cuando la funcin se ejecuta y se
destruye en el momento en que la funcin termina, una variable local solo se
conoce dentro de la funcin en la que es declarada.

48

3.6.1 Variables externas

Una variable externa se declara fuera de cualquier funcin y es conocida por
todas las funciones del programa., es decir estn disponibles para todas las
funciones Las variables externas permanecen durante toda la duracin del
programa, cualquier funcin puede tener acceso a variables externas haciendo
referencias a ellas solamente por su nombre.

3.6.2 Variables Estticas

Una variable esttica mantendr su valor entre una llamada y otra a la funcin,
solo se conoce por su funcin y permanecer mientras lo haga el programa.

3.6.3 Variables registro

Una declaracin register indica al compilador C que la variable en cuestin se
emplear constantemente, este tipo de variables deben ser colocadas en
registros de la mquina, logrndose programas mas pequeos y rpidos.
La declaracin register se realiza de la siguiente manera:
register int x;
register char c;
Solo algunas variables de una funcin se pueden mantener en registros, el
compilador puede ignorar la sugerencia de register.

3.7 F UNCIONES

PREDEFINIDA S EN

49

En C existen libreras con una gran cantidad de funciones predefinidas, las

funciones, tipos y macros de la biblioteca estndar estn declarados en
encabezados o headers estndar:

<assert.h>

<float.h>

<math.h>

<stdarg.h>

<stdlib.h>

<ctype.h>

<limits.h>

<setjmp.h>

<stddef.h>

<string.h>

<errno.h>

<locale.h>

<signal.h>

<stdio.h>

<time.h>

Referirse apndice B de libro El lenguaje de programacin C 4 para una

definicin completa de las principales funciones de las libreras estndar de C

ACTIVIDAD DE APRENDIZAJE
El estudiante analizar por lo menos 10 funciones predefinidas de C, las
cuales forman parte de la librera estndar del lenguaje.
Estas debern ser discutidas en clase, tratando de mencionar diferentes tipos
de funciones, es decir de entrada y salida, de operaciones para archivos,
funciones de error, funciones para cadenas de caracteres, funciones
matemticas, etc.

3.8 R ECURSIVIDAD
En los programas desarrollados en C las funciones pueden llamarse a si
mismas es decir son recursivas, esto es si dentro del cuerpo de la funcin existe

El Lenguaje de programacin C, autores Brian W Kernighan y Dennis M. Ritchie, editorial

Pearson Educacin

50

una expresin donde se llama a la misma funcin, se podra conocer tambin

como definicin circular.
Un ejemplo de una funcin recursiva se muestra a continuacin
factr(n)

/* recursiva */

int n;
{
int respuesta;
if(n==1) return(1);
respuesta=factr(n-1)*n;
return(respuesta);
}

51

AUTOEVALUACIN
1. Explica que son las variables externas en una funcin escrita en C
Una variable externa se declara fuera de cualquier funcin y es conocida
por todas las funciones del programa. Las variables externas permanecen
durante toda la duracin del programa.
2. En qu consiste el concepto de recursividad?
Es la capacidad que tienen las funciones desarrolladas en C de
llamarse a si mismas.
3. Menciona 3 funciones de la biblioteca estndar de C
printf

getchar

putchar

4. En qu consiste la llamada a una funcin por valor?

copia el valar de cada uno de los argumentos en los parmetros formales
de la funcin.
5. Indique los tipos de datos que pueden ir precedidos del modificador register
char e int

52

UNIDAD 4
ESTRUCTURAS DE CONTROL DE FLUJO
OBJETIVO:
Que el estudiante aprenda a utilizar las sentencias condicionales, los ciclos, las
proposiciones de rompimiento de la secuencia normal de ejecucin de un
programa (break, continue, goto y etiquetas) para la toma de decisiones en la
elaboracin de programas con el lenguaje de programacin C, al finalizar este
captulo podr realizar programas ms complejos para la solucin de los
problemas que se le planteen.

TEMARIO
4.1 PROPOSICIONES Y BLOQUES
4.2 SENTENCIAS CONDICIONALES
4.2.1 IF ELSE
4.2.2 ELSE IF
4.2.3 SWITCH
4.3 CICLOS Y BUCLES
4.3.1 WHILE Y FOR
4.3.2 DO WHILE
4.4 BREAK Y CONTINUE
4.5 ETIQUETAS Y GOTO

53

Mapa Conceptual Unidad 4

Proposiciones y
bloques

Sentencias
Condicionales

Ciclos y Bucles

if else

while y for

else if

Do While

switch

break y
continue

Etiquetas y
goto

54

INTRODUCCIN
El lenguaje C cuenta con una serie de expresiones para poder controlar la
secuencia en la ejecucin de los diversos bloques que componen el programa,
se cuenta con sentencias condicionales y con ciclos o bucles

Las sentencias condicionales permiten la ejecucin de solo un bloque de

instrucciones basndonos en el resultado de una condicin.

Los ciclos o bucles nos permiten la repeticin de un bloque de instrucciones

hasta que una condicin se cumpla.

55

4.1 PROPOSICIONES Y BLOQUES

En C una expresin como x=0 o i++ o cualquier otra, se convierte en una
proposicin cuando va seguida de un punto y coma ;, por ejemplo en las
siguientes expresiones:
x=0;
i++;
En el lenguaje C el punto y coma es el terminador de proposicin, no
cumple funciones de separador como en otros lenguajes.
Las llaves { } se ocupan para agrupar declaraciones y proposiciones
dentro de un bloque, es decir dentro de una proposicin compuesta, por lo que
son equivalentes, sintcticamente hablando, a una proposicin sencilla. Como
ejemplo podemos citar:

Las llaves que encierran todas las proposiciones de una funcin.

Las llaves que encierran proposiciones mltiples com en el caso de if,

else, while, for.
Algunas caractersticas importantes de los bloques son:

Dentro de un bloque se pueden declarar variables.

No se debe escribir un punto y coma despus de la llave derecha } que

cierra el bloque.
Las declaraciones de variables pueden seguir a la llave izquierda { que

inicia cualquier proposicin compuesta, siendo stas internas al bloque donde

son declaradas, y no tienen relacin alguna con variables declaradas en
bloques externos, y permanecern hasta que se encuentre la llave derecha }
que cierra el bloque, que corresponda con la llave inicial, ejemplo:
if ( x> 0) {

56

int i; /* se declara una nueva variable entera i */

for (i=0; i<n; i++)
.

}
Recordemos que un comentario se puede escribir al finalizar una
proposicin, como sucede en la declaracin de la variable entera i, siempre y
cuando lo encerremos entre /* y */ todo lo que va entre estos smbolos es
considerado un comentario y no ser analizado por el compilador C.
La variable i solo estar disponible en la rama verdadera del if, por lo
que esta i no tiene ninguna relacin con alguna otra variables llamada i fuera de
este bloque, su valor se pierde en el momento de encontrar la llave derecha }
que indica terminacin del bloque.
Una variable automtica que se declara e inicializa en un bloque, deber
ser inicializada cada vez que se entra al bloque
Una variable esttica se inicializa solamente la primera vez que se entra
al bloque.
Como un ejemplo final analicemos las siguientes proposiciones:

Int a
Int b
f1 (double a)
{
double b;

57

En este ejemplo
En la funcin f1 las ocurrencias de a se refieren al parmetro que es double.
Fuera de f1 se refieren al int externo, lo mismo ocurre para la variable b.
Se recomienda evitar nombres de variables dentro de una funcin que
sean idnticos con nombres de un alcance exterior, para evitar errores o
confusiones.

ACTIVIDAD DE APRENDIZAJE
El estudiante deber realizar un programa que utilice una variable i externa y
una variable i interna a un bloque de instrucciones, realizar variaciones del valor
de dicha variable, tanto fuera como dentro del bloque, mandando a imprimir su
valor varias veces para verificar que son dos variables independientes.

4.2 S ENTENCIAS C ONDICIONALES

Las sentencias condicionales nos sirven para poder elegir la ejecucin de uno u
otro bloque en base al resultado de una condicin previamente establecida, es
decir podemos escoger uno de dos caminos en base a que se cumpla o no una
condicin.

4.2.1 If Else
Esta proposicin se utiliza para tomar decisiones, su sintaxis es:

58

if (expresin)
proposicin1
else
proposicin2
La expresin entre parntesis ( ) se evala, si es verdadera (tiene un
valor diferente de 0) se ejecuta la proposicin1, pero si es falsa (tiene un valor
igual a 0) entonces se ejecuta la proposicin2, esto siempre que exista una
parte de else, ya que esta ltima parte es opcional.
Como un if prueba el valor numrico de una expresin, podemos abreviar
el cdigo, por ejemplo:
Utilizar:

if (expresin)

En lugar de: if (expresin = 0)

Como la parte del else es opcional, en ocaciones cuando existen ifs
anidados puede existir cierta ambigedad al escribir un else, esto se resuelve al
asociar el else con el if anterior, es decir con el mas cercano,es recomendable
utilizar llaves { } para forzar la asociacin correcta, por ejemplo:
if (a>0)
if (n>m)
x=n;
else
x=m;
El else corresponde al if ms interno es decir si no se cumple la
expresin (n>m) entonces se ejecutarn las expresiones del else. Si lo que se

59

quiere es que el else se ejecute si la expresin (a>0) no se cumple (Asociado al

primer if) se usarn llaves:
if (a>0) {
if (n>m)
x=n;
}
else
x=m;

Por claridad en la programacin podramos usar un comentario al final de

cada if else para sealar su final:
/* End if */
Por ejemplo:
if (a>0)
if (n>m)
x=n;
else
x=m;
/*end if*/
/*end if*/
De esta manera evitamos ambigedades, o falta de claridad en la
programacin.

60

4.2.2 Else If
Para poder contar con una desicin mltiple, es decir poder evaluar una
condicin y en base al resultado de la misma tomar un camino determinado se
utiliza esta instruccin, su sintaxis es la siguiente:
if (expresin)
proposicin
else if (expresin)
proposicin
else if (expresin)
proposicin
else if (expresin)
proposicin
else
proposicin
Todas las expresiones se evaluarn en orden, si cualquiera de ellas es
verdadera, la proposicin asociada con ella se ejecuta, terminando con ello la
cadena de decisiones, como hemos mencionado, cada proposicin puede ser
una proposicin simple o un grupo de ellas dentro de llaves {.}.
El ltimo else, en el ejemplo anterior, maneja el caso ninguno de los
anteriores, es el caso por default que se ejecutar cuando ninguna de las
condiciones establecidas se satisface, no siempre se utiliza, pero nos resulta til
para detectar errores o para una condicin imposible

61

ACTIVIDAD DE APRENDIZAJE
El profesor deber solicitar a los alumnos la realizacin de, por lo menos 2
programas que resuelvan mediante el uso de if-else y/o de else-if problemas
sencillos pero que sirvan para comprender completamente el uso de estas
sentencias condicionales.

4.2.3 Switch
Esta es una decisin mltiple que prueba si una expresin coincide con unos de
un nmero de valores constantes enteros, su sintaxis es la siguiente:
switch (expresin) {
case exp-const:proposiciones
case exp-const: proposiciones
default: proposiciones
}
Cada case se etiqueta con uno o ms valores constantes enteros o
expresiones constantes enteras, cuando un case coincide con el valor de la
expresin, la ejecucin comienza en ese punto, es importante mencionar que
todas las expresiones case deben ser distintas.
La etiqueta default se ejecuta si ninguno de los otros casos se satisfizo, y
es optativo, si esta etiqueta no se escribe y ninguno de los casos coincide no se
tomar accin alguna.

62

ACTIVIDAD DE APRENDIZAJE
Los alumnos realizarn, compilarn y ejecutarn el siguiente programa5.
#include <Stdio.h>
main () /* cuenta dgitos, espacios en blanco y otros caracteres */
{
int c, i, nwhite, nother, ndigit[10];
nwhite = nother = 0;
for(i=0; i<10; i++)
ndigit[i] = 0;
while ((c = getchar()) != EOF) {
switch ( c) {
case 0: case 1: case 2: case 3: case 4:
case 5: case 6: case 7: case 8: case 9:
ndigit[c-0]++;
break;
case :
case \n:
case \t:
nwhite++;
break;
default:
nother++;
break;
}
}
printf(digitos =);
for (i=0; i<10; i++)
printf(%d, ndigit[i]);
5

Tomado del libro El Lenguaje de programacin C; autor Brian W. Kernighan, Dennis M Ritchie; editorial
Pearson Educacin

63

printf(,espacios blancos = %d, otros= %d\n,

nwhite, nother);
return 0;
}

4.3 C ICLOS

Y BUCLES

Los ciclos tambin llamados bucles se utilizan para repetir proposiciones o

bloques mientras cierta condicin se cumpla, en la actividad de aprendizaje
anterior utilizamos estos ciclos para poder resolver el problema, ahora los
explicaremos a detalle.

4.3.1 While y For

La sintaxis de estas expresiones es la siguiente:
while (expresin)
proposicin
La expresin es evaluada, si es diferente de cero, se ejecuta la
proposicin y se vuelve a evaluar la expresin, este ciclo se repite hasta el
momento en que la expresin es igual a cero, en dicho momento se suspende
la ejecucin y se contina el desarrollo del programa a continuacin de la
proposicin.
for (expresin1; expresin2; expresin3)
proposicin
Normalmente los 3 componentes del ciclo for son expresiones,
expresin1 y expresin3 son asignaciones o bien llamadas a funciones y

64

expresin2 es una expresin de relacin, se puede omitir cualquiera de las 3

expresiones pero se deben mantener los ;
El ciclo for escrito anteriormente equivale al siguiente ciclo while:
expresin1;
while (expresin2) {
proposicin
expresin3;
}
4.3.2 Do While
Su sintaxis es la siguiente:
do
proposicin
while (expresin);
La proposicin se ejecuta por primera vez, despus se evala la
expresin, si es verdadera entonces se vuelve a ejecutar la proposicin, as
sucesivamente hasta que la expresin regrese un valor de falso, terminando de
esta manera el ciclo.

4.4 B REAK

C ONTINUE

En muchas ocasiones, y dependiendo de cada problema a resolver, es

conveniente terminar un ciclo de una manera distinta, es decir que no sea
comprobando al inicio o al final del ciclo. La proposicin break nos sirve para
lograr una salida anticipadapara un ciclo o bucle (for, while o do) o bien un
switch.

65

Un break provoca que el ciclo o switch ms interno que lo encierra

termine inmediatamente.

4.5 E TIQUETAS

Y GOTO

Una excelente funcion de C para controlar la secuencia de proposiciones a

ejecutar es goto, que en conjunto de las etiquetas dan una importante funcin a
este lenguaje de programacin.
Formalmente esta proposicin no es necesaria, en la prctica es muy
sencillo escribir cdigo de programacin sin ella, sin embargo en algunas
situaciones puede ser de gran ayuda, la ms comn consiste en abandonar un
procedimiento en una proposicin profundamente anidada, es como salir de 2, 3
o ms ciclos a la vez. Si utilizamos la proposicin Break salimos del ciclo ms
interno y con goto abandonamos todos los ciclos, reiniciando la ejecucin en
donde est indicada la etiqueta.
Por ejemplo:
for ()
for () {

if (desastre)
goto error;
}

error:
arreglamos el desastre

66

ACTIVIDAD DE APRENDIZAJE
El profesor deber solicitar a los alumnos la realizacin de, por lo menos 2
programas que resuelvan mediante el uso de ciclos, break, continue, goto y
etiquetas problemas sencillos pero que sirvan para comprender completamente
su uso.

67

AUTOEVALUACIN
1. Menciona 2 ejemplos de ciclos o bucles.

while, for, do-while (cualquiera 2 de ellos).

2. Menciona dos ejemplos de sentencias condicionales.

if-else, else-if, switch (cualquiera dos de ellos).

3. Qu es un ciclo o bucle?

Es una proposicin o bloque que se repite mientras una condicin se

cumpla.

4. Para qu nos sirve una sentencia condicional?

Nos permite ejecutar una proposicin u otra dependiendo del valor

quetoma

una

condicin

establecida,

pueden

ser

sentencias

condicionales mltiples, es decir con ms de 2 tomas de desiciones.

5. Qu es una proposicin en el lenguaje C?
En C una expresin cualquier, se convierte en una proposicin cuando
va seguida de un punto y coma ;

68

UNIDAD 5
TIPOS DE DATOS ESTRUCTURADOS
OBJETIVO
Que el estudiante aprenda a utilizar arreglos, estructuras, uniones y campos de
bits.

TEMARIO
5.1 ARREGLOS.
5.2 ESTRUCTURAS.
5.2.1 CONCEPTOS BSICOS SOBRE ESTRUCTURAS.
5.2.2 ESTRUCTURAS Y FUNCIONES.
5.2.3 ARREGLOS DE ESTRUCTURAS.
5.2.4 APUNTADORES O ESTRUCTURAS.
5.2.5 ESTRUCTURAS AUTORREFERENCIADAS
5.3 UNIONES
5.4 CAMPOS DE BITS

69

MAPA CONCEPTUAL

Tipos de datos
estructurados

Arreglos

Estructuras

Uniones

Campos de Bits

70

INTRODUCCIN
El alumno aprender:

El concepto y manejo de arreglos y estructuras en el lenguaje de

programacin C

Aprender el manejo de uniones y el concepto de campos de bits

herramientas importantes en C.

71

5.1 ARREGLOS
Un apuntador es una variable que contiene la direccin de una variable, estos
son muy utilizados en C, los apuntadores y los arreglos estn muy
relacionados, en este captulo analizaremos los arreglos y en el siguiente los
apuntadores.
En C los arreglos se componen de posiciones contiguas de memoria,
donde la direccin ms baja corresponde al primer elemento y la ms alta al
ltimo elemento.
La sintaxis general para un arreglo unidimensional es:
type var_nombre[dimensin];
Se requiere que a cada arreglo se le d una longitud en la sentencia de
declaracin, en C los arreglos empiezan en cero, por ejemplo, cuando
escribimos:
char p[10];
Declaramos un arreglo de caracteres que tiene 10 elementos, de p[0} a
p[9].
char x[10];
Declaramos un arreglo de nmeros enteros de 10 elementos de x[0] a
x[9].

ACTIVIDAD DE APRENDIZAJE
El estudiante analizar el siguiente ejemplo y lo discutir en clase:
int i[10];
int cont;
for (cont=0;cont<10;++cont) i[cont]=cont;

72

Nota: Recordar la diferencia entre ++var y var++, recordar la estructura del for

Los ejemplos anteriores hacen referencia a los arreglos en una

dimensin, pero C cuenta con arreglos de dos o ms dimensiones, es decir
con arreglos multidimensionales. Para declarar un arreglo entero bidimensional i
con un tamao de 10,20 debemos escribir:
int i[10][20];
En C se indica cada dimensin entre parntesis cuadrados, no utiliza
comas como separadores como se hace en otros lenguajes de programacin.
Si queremos hacer referencia a un elemento del arreglo, por ejemplo el
4,6 debemos utilizar la siguiente expresin:
d[4][6]
Para acabar de entender cmo se guarda un arreglo bidimensional en
memoria:
Segundo ndice.
Direccin de memoria m

m+7
0,0

0,1

0,2

0,3

0,4

0,5

0,6

0,7

1,0

1,1

1,2

1,3

1,4

1,5

1,6

1,7

2.0

2,1

2,2

2,3

2,4

2,5

2,6

2,7

3,0

3,1

3,2

3,3

3,4

3,5

3,6

3,7

4,0

4,1

4,2

4,3

4,4

4,5

4,6

4,7

Primer ndice

m+(rxc)-1

73

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar un programa para llevar un arreglo multidimensional
donde coloque Nombre, Apellido Paterno y Apellido Materno de todos los
alumnos inscritos en su grupo.
En clase analizar las diversas soluciones presentadas.

5.2 E STRUCTURAS
Una estructura en C es una coleccin de una o ms

variables, de tipos

posiblemente diferentes, que se referencian bajo un mismo nombre, con el

objeto de mantener en un sitio la informacin que est relacionada.
En otros lenguajes las estructuras se conocen como registros, nos
ayudan a organizar datos complicados.
Como ejemplo podemos mencionar el nombre de un apersona y su
direccin agrupadas en una lista de correo es un conjunto de informacin
relacionada.
5.2.1 Conceptos bsicos de estructuras
Una definicin de la estructura forma una plantilla que puede ser utilizada para
crear estructuras variables.
Cada estructura se forma de una o ms variables que estn relacionadas
lgicamente, dichas variables se denominan elementos de la estructura
Un ejemplo sencillo de estructuras puede ser utilizada para realizar una
grfica cada punto de la misma tiene una coordenada x y una coordenada y,
ambas enteras.

74

(x,y)
(0,0)

Estos dos componentes pueden ser colocados en una estructura declarada

como se muestra a continuacin:
struct point {
int x;
int y;
};

Con la palabra reservada struct sirve para declarar una estructura, esta
es una lista de declaraciones entre llaves, se utiliza un nombre de forma
optativa como rtulo de la estructura, en el ejemplo anterior el rtulo de la
estructura es point, este puede ser utilizado como una abreviatura para la
parte de declaraciones entre llaves.
Las variables nombradas dentro de una estructura se denominan
miembros.
Un miembro, un rtulo y una variable ordinaria, esto es, no miembro,
pueden tener el mismo nombre sin causar ningn conflicto, ya que se pueden
distinguir fcilmente por el contexto en que se utilicen.
En diferentes estructuras se pueden encontrar los mismos nombres de
miembros, sin que se tenga algn problema, pero por claridad y estilo se
deberan utilizar los mismos nombres solo para objetos estrechamente
relacionados.

75

Una declaracin struct define un tipo, la llave derecha que cierra la lista
de miembros puede ser seguida por una lista de variables, como lo hacemos
para cualquier tipo bsico:
struct {..} x, y, z;
Es muy similar a escribir:
int x, y, z;

5.2.2 Estructuras y funciones

Las estructuras, como grupos de variables conectados lgicamente, se pueden
pasar de una manera sencilla a las funciones, y las funciones pueden
regresarlas.
Las nicas operaciones vlidas sobre una estructura son copiarla o
asignarla como unidad, tomar su direccin con & y tener acceso a sus
miembros. La copia y la asignacin incluyen pasarlas como argumentos a
funciones y tambin regresar valores de funciones.

5.2.3 Arreglos de estructuras

La utilizacin ms comn de las estructuras puede ser la de arreglo de
estructuras, primero hay que definir una estructura y luego declarar una
variable tipo arreglo que contenga dicha estructura por ejemplo, declaremos la
siguiente estructura:
struct dir
char nombre [30];
char calle [40];
char ciudad [20];
char prov [20];

76

unsigned long int DP,

} ainfo, binfo, cinfo;

Con esto definimos una estructura llamada dir y se declaran las variables
ainfo, binfo, cinfo, del tipo dir.
Ahora declararemos un arreglo de cien elementos de estructuras del tipo dir,
esto es:
struct dir ainfo[100];
Esto crea cien conjuntos de variables que estn organizadas como se
defini en la estructura dir.
Para imprimir el cdigo postal DP de la estructura 3 debemos escribir:
printf(%d,ainfo[2].DP);
Como en todas las variables de arreglos, los arreglos de estructura
empiezan sus contadores en cero.

5.2.4 Apuntadores a estructuras

Para ejemplificar algunas consideraciones involucradas con apuntadores y
arreglos de estructuras, tomaremos el siguiente ejemplo de un programa de
conteo de palabras reservadas6:
#include <Stdio.h>
#include <ctype.h>
#include <string.h>
#define MAXWORD 100

Ejemplo tomado del libro: El Lenguaje de Programacin C, de Brian W. Kernighan y Dennis M. Ritchie,
editorial Pearson Educacin.

77

int getword(char *,int);

struct key *binsearch(char *. Struct key *, int);

/* cuenta palabras reservadas de C, con apuntadores */

main()
{
char Word[MAXWORD];
struct key *p;

while (getword(Word,MAXWORD) != EOF)

If (isalpha(Word[0]))
if((p=binsearch(Word, keytab, NKEYS)) != NULL)
p->count++;
for(p = keytab; < keytab + NKEYS; p++)
if (p-> count > 0)
printf(%4d %s/n,p->count, p->Word);
return 0;
}
/*binsearch: encuantra una palabra en tab[0] tab[n-1] */
struct key *binsearch(char *Word, struct key *tab, int n)
{
int cond;
struc key *low = &tab[0];
struct key *high = &tab[n];
struct key *mid;

while (low < high){

mid = low + (high-low) / 2;
if((cond = strcmp(Word, mid->Word)) <0)
high = mid;
else if(cond >0)

78

low = mid +1;

else
return mid;
}
return NULL;
}

Este programa que cuenta palabras reservadas comienza con la

definicin de keytab. La funcin principal lee de la entrada con llamadas
repetidas a la funcin getword, que trae una palabra a la vez. Cada palabra se
consulta en keytab.
En este ejemplo debemos notar:
La declaracin de binsearch debe indicar que regresa un apuntador a
struct key en lugar de un entero, esto se declara en el prototipo de la funcin
como en binsearch. Si la funcin binsearch encuentra la palabra, regresa el
apuntador a ella, en caso contrario regresa NULL.
Ahora se tiene acceso a los elementos de keytab por medio de
apuntadores.
Los inicializadores para low y high son apuntadores al inicio y justo
despus del final de la tabla.
Como la suma de apuntadores es ilegal, utilizaremos la resta, high-low
es el nmero de elementos, por lo que mid = low + (high-low) /2 har que mid
apunte al elemento que est a la mitad entre low y high.
Este ejemplo quedar ms claro cuando se halla estudiado el captulo de
apuntadores.

79

ACTIVIDAD DE APRENDIZAJE
El estudiante analizar en clase el ejemplo anterior, hasta comprender en su
totalidad el funcionamiento de todo el programa.
El profesor deber aclarar todas las dudas que se presenten.

5.2.5 Estructuras autorreferenciadas.

Para ejemplificar este concepto debemos resolver la siguiente pregunta: Cmo
podemos organizar los datos para manejar eficientemente una lista de palabras
arbitrarias?, es decir minimizando el tiempo de ejecucin de un programa.
Una posible solucin es mantener siempre ordenado el conjunto de palabras
que ya se han visto, colocando cada una en su posicin correcta cuando llega.
No se podra realizar recorriendo las palabras en un arreglo lineal, ya que el
tiempo de ejecucin sera demasiado, en lugar de esto se debe utilizar una
estructura de datos llamada rbol binario.
Este rbol contiene un nodo por cada palabra distinta, cada uno de los nodos
debe contener:

Un apuntador al texto de la palabra.

Una cuenta del nmero de ocurrencias.

Un apuntador al nodo hijo de la izquierda.

Un apuntador al nodo hijo de la derecha.

Un nodo solo puede tener 0, 1 o 2 hijos.

Cada uno de los nodos se representa convenientemente como una estructura
con cuatro componentes:
struct tnode{

/* el nodo del rbol */

80

char *word;

/* apuntador al texto */

int count;

/* nmero de ocurrencias */

struct tnode *left;

/* hijo a la izquierda */

struct tnode *right;

/*/hijo a la derecha */

};

Esta declaracin es recursiva, puede parecer riesgosa, pero es

totalmente correcta.
Es invlido que una estructura contenga una instancia de s misma, pero
en el ejemplo:
struct tnode *left;
O cualquiera otra del ejemplo, declaran a left como un apuntador a
tnode, no como un tnode en s.
Esto es lo que se conoce como una estructura autorreferenciada, en
ocasiones se requiere de una variante de este tipo de estructuras, en donde dos
estructuras hacen referencia una a la otra.

ACTIVIDAD DE APRENDIZAJE
El estudiante del libro El lenguaje de programacin C de Brian W Kernighan y
Dennis M.Ritchie, editorial Pearson Educacin, realizar, analizar, compilar y
ejecutar los problemas presentados en las hojas 155 y 156 para entender el
concepto de estructuras autorreferenciadas.
El profesor deber aclarar todas las dudas que se presenten.

81

5.3 U NIONES
En el lenguaje de programacin C una unin es un lugar de la memoria que se
utiliza por algunas variables diferentes y posiblemente de diferentes tipos.
En el siguiente ejemplo se da la unin llamada u entre un carcter y un
entero:
unin u {
int i;
char ca;
};
Como ocurre en el caso de las estructuras, esta unin no declara
ninguna variable, la variable puede ser declarada colocando su nombre al final
de la definicin o por medio de una sentencia de declaracin separada, para
declarar una variable tipo unin llamada cnvt, utilizando la definicin que acaba
de darse se debe escribir:
union u cnvt;

5.4 C AMPOS

DE BITS .

A diferencia de otros lenguajes C incluye un mtodo para acceder a un solo bit

dentro de un byte mtodo para acceder a un solo bit dentro de un byte,
podemos mencionar como las utilidades principales de esta funcin:

Si la capacidad del almacenaje es limitada se pueden almacenar algunas

variables booleanas (cierto/falso) en un solo byte de informacin.

Algunas interfaces de dispositivos transmiten informacin codificada en

bytes dentro de un byte.

Algunas rutinas criptogrficas necesitan acceder a los bits en forma

independiente dentro de un byte.

82

El mtodo utilizado en C para acceder a los bits est basado en las

estructuras, como ejemplo mencionaremos la siguiente estructura donde se
definen tres variables de un bit cada una:
Struct dispositivo {
Unsigned activo : 1;
Unsigned listo : 1;
Unsigned xmt_error : 1;
} codi_dispositivo;

Las tres variables se declaran como unsigned por que un bit no puede
tener signo, los nicos valores que puede tener un bit son 0 y 1. La variable
estructura codi_dispositivo se puede utilizar para decodificar informacin desde
el puerto de una cinta magntica, por ejemplo el siguiente fragmento de cdigo
lo utilizamos para escribir un byte de informacin en la cinta y comprobaremos
los errores utilizando codi_dispositivo.
Wr_cinta(c)
Char c;
{
while(!codi_dispositivo-ready) rd(&codi_dispositivo); /* espera */
wr_to_tape(c); /* escribe un byte */
while (codi_dispositivo.activo) rd(&codi_dispositivo); /* espera hasta que
la informacin se escriba */
if(dev_code.xmt_error) printf(error de escritura);
}

A continuacin escribiremos la variable del campo de bit codi_dispositivo

como se representa en memoria:
Un octeto (BYTE)

83

No usado
Codi_disositivo.activo
Codi_dispositivo.listo
Codi_dispositivo.xmt_error

84

AUTOEVALUACIN
1. Qu es un arreglo?

En C los arreglos se componen de posiciones contiguas de

memoria, donde la direccin ms baja corresponde al primer
elemento y la ms alta al ltimo elemento.

2. En C existen arreglos multidimensionales?

Cierto

3. Qu es una estructura?

Una estructura en C es una coleccin de una o ms variables, de

tipos posiblemente diferentes,

que se referencian bajo un mismo

nombre, con el objeto de mantener en un sitio la informacin que

est relacionada..
4. Defina una estructura denominada jugador que sea capaz de almacenar la
siguiente informacin: nombre del jugador, nombre del grupo, tanteo medio.
struct jugador{
char jugador_nombre[40];
char jugador_grupo[40];
float tanteo_medio;
};
5. Utilizando jugador de la pregunta anterior, declarar un arreglo de
estructuras de 100 elementos. Llamarlo p_info.
struct jugador p_info[100]

85

UNIDAD 6
APUNTADORES

OBJETIVO:
Que el estudiante aprenda el concepto de apuntadores, las operaciones que
pueden realizarse con ellos, comprenda la aritmtica de direcciones para
utilizarlos en la solucin de problemas complejos de programacin.

TEMARIO
6.1 . DEFINICIN DE APUNTADORES
6.2 OPERACIN DE APUNTADORES
6.3 . APUNTADORES Y ARREGLOS
6.4 ARITMTICA DE DIRECCIONES
6.5 APUNTADORES A CARACTERES Y FUNCIONES
6.6 ASIGNACIN DINMICA DE MEMORIA

86

MAPA CONCEPTUAL

Apuntadores

Definicin de
apuntadores

Operacin de
apuntadores

Apuntadores y
Arreglos

Apuntadores a
caracteres y
funciones

Aritmetica de
direcciones

Asignacin
dinmica de
memoria

87

INTRODUCCIN
En captulos anteriores ya se han utilizado los apuntadores, pero hasta este
captulo aprenderemos a utilizarlos con todo detalle, esto nos permitir realizar
programas cuyo tiempo de ejecucin sea ms rpido.
El uso de los apuntadores es importante para realizar de forma correcta
programas en el lenguaje de programacin C.
El alumno aprender:

El concepto y manejo de arreglos y estructuras en el lenguaje de

programacin C

Aprender el manejo de uniones y el concepto de campos de bits

herramientas importantes en C.

88

6.1 DEFINICIN DE APUNTADORES.

En pocas palabras un apuntador es una variable que contiene una direccin de
memoria. Esta direccin es la posicin de alguna variable en memoria.
Entonces podemos decir que un apuntador apunta a una variable, a la
que se puede accesar de forma indirecta con los operadores especiales sobre
punteros: * y &.
Una computadora tiene un arreglo de celdas de memoria numeradas o
direccionadas

consecutivamente,

esta

celdas

se

pueden

manipular

individualmente o en grupos contiguos.

Cualquier byte puede ser un chat.
Un par de celdas de un byte pueden ser un entero short
Cuatro bytes consecutivos forman un long.
Un apuntador es un grupo de celdas (generalmente 2 o 4) que pueden
mantener una direccin.
Una computadora tpica tiene un arreglo de celdas de memoria
numeradas consecutivamente, que pueden manipularse individualmente o en
grupos contiguos, recordemos que cualquier byte puede ser un char, un par de
celdas de un byte pueden tratarse como un entero short, y cuatro bytes
contiguos forman un long, siempre un apuntador es un grupo de celdas que
pueden mantener una direccin.
A manera de ejemplo vamos a considerar: c es una variable tipo chat, p
es un apuntador, que est apuntando a la variable c, este ejemplo puede
representarse como se muestra en la siguiente figura:
p:

c:

89

6.2 O PERACIN

DE

A PUNTADORES

Existen dos operadores especiales sobre apuntadores & y *, ambos son

operadores unarios, Recordemos que un operador unario se aplica a un solo
operando.
El operador & sirve para dar la direccin de un objeto, y solo se aplica a
objetos que estn en memoria, como son variables y elementos de arreglos, no
puede aplicarse a expresiones, constantes o variables tipo registro, lo podemos
recordar como la direccin de,
La proposicin:
p = &n;
Asigna la direccin de n a la variable p, por esto podemos decir que:
p apunta a n
El operador * que se conoce como operador de indireccin o
desreferencia, accede al contenido de una variable cuya direccin es el valor de
un puntero, lo podemos recordar cmo en la direccin.
Por ejemplo si xyz y k son variables enteras y h es un apuntador a
entero, entonces:
h = &xyz;
k = *h;
asigna el valor de xyz a k
Los apuntadores tienen que haber sido declarados.
Para declarar h como un apuntador a entero, debemos utilizar:
int *h;
Para declarar x como un apuntador a float, se indica:

90

float *x;
Debemos de tener la seguridad de que las variables tipo apuntador
siempre apunten al tipo de datos correcto, cuando declaramos que un
apuntador es del

tipo int, entonces cualquier direccin que tenga este

apuntador debe apuntar a una variable entera.

Como sucede con cualquier variable, un apuntador se puede utilizar en el
lado derecho de las sentencias de asignacin para asignar su valor a otra
variable, como lo podemos ver a continuacin:
int x;
unsigned y;
int *p1, p2;
p1= &x;

/* da la direccin de x a p2 */

y=p2;
printf (%u,y);

/* imprime el valor decimal de la direccin de x no el

valor de x! */

6.3 A PUNTADORES

A RREGLOS

En el lenguaje de programacin C existe una fuerte relacin entre los

apuntadores y los arreglos, Cualquier operacin que pueda lograrse por medio
de indexacin de un arreglo tambin puede lograrse por apuntadores, con el
uso de apuntadores se logra una versin de ejecucin ms rpida, pero algo
ms difcil de entender.
Los apuntadores de cualquier tipo de arreglos funcionan como una
alternativa a la indexacin.
La declaracin:
int m[10];

91

Define un arreglo m de tamao 10, es decir de 10 objetos consecutivos

agrupados en memoria, llamados m[0], m[1], m[2], m[3],..,m[9]

Cada uno de los 10 objetos es del tipo entero

m
:

m[0]

m[1]

m[2]

m[3] m[4]

m[5]

m[6] m[7]

m[8]

m[9]

La notacin m[i] se refiere al (i-simo +1) elemento del arreglo, por

ejemplo: m[3] se refuere al cuarto elemento del arreglo, ya que el primer ndice
es 0, el segundo 1, el tercero 2 y el cuarto elemento lleva el ndice 3
Si pm es un apuntador a un entero y fue declarado como:
int *pm;
la asignacin siguiente:
pm = &m[0];
hace que pm apunte al elemento cero del arreglo m; es decir pm contiene la
direccin de m[0]
pm:

m
:

m[0]

m[1]

m[2]

m[3] m[4]

m[5]

Ahora la siguiente asignacin:

x=*pm;
copiar el contenido de m[0] en la variable x.

m[6] m[7]

m[8]

m[9]

92

Si pm apunta a un elemento en particular de un arreglo, entonces pm +1

apunta al siguiente elemento, pm + i apuntar i elementos despus de pm, de
manera inversa pm -1 apunta un elemento anterior a pm y pm i apunta i
elementos anteriores a pm.
Si pm apunta a m[0],
*(pm+1)
Se refiere al contenido de m[1], pm + i es la direccin de m[i] y *(pm+i) es
el contenido de m[i]
pm:

pm+1:

pm+2:

m
:

m[0]

m[1]

m[2]

m[3] m[4]

m[5]

m[6] m[7]

m[8]

m[9]

Esto es correcto sin importar el tipo o tamao de las variables del arreglo m,
La relacin entre indexacin y aritmtica de apuntadores es muy
estrecha.

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar la solucin de un problema definido por el profesor de
dos maneras distintas:
Mediante el uso de arreglos con ndices.
Mediante el uso de arreglos y apuntadores
Nota: En lo posible tratar de comparar los tiempos de ejecucin de ambas
soluciones.

93

6.4 A RITMTICA

DE DIRECCI ONES .

El significado de agregar 1 a un apuntador, y por extensin, toda la aritmtica

de apuntadores, es que pm+1 apunta al siguiente objeto delante de pm y pm+i
apunta al i-simo objeto delante de pm.
Solo existen dos operadores aritmticos que se pueden utilizar con los
apuntadores, + y -.
Para entender lo que ocurre con la aritmtica de apuntadores,
supongamos que p1 es un apuntador a entero con valor actual de 2000,
despu0s de la expresin:
p1++;
El contenido de p1 ser 2002 y no 2001. Cada vez que p1 se incrementa,
apuntar al entero siguiente, que en casi todas las computadoras ocupan 2
bytes, esto es igual en los decrementos, por ejemplo:
p1--;
Har que p1 tenga el valor de 1998, suponiendo que originalmente era
2000.
Debemos recordar que cada vez que un apuntador se incrementa
apuntar a la posicin de memoria del siguiente elemento de su tipo y cada vez
que se decremente, apuntar a la posicin del elemento anterior de su tipo.
Los apuntadores a carcter normalmente coinciden con la aritmtica
normal, pero para todos los dems apuntadores se incrementarn o
decrementarn segn la longitud del tipo de dato al que apunten

6.5 A PUNTADORES

A CARACTE RES Y FUNCIONES

Una constante de caracteres, escrita como:

94

Soy una cadena

Al estar entre comillas se considera constante de caracteres.
Este conjunto de caracteres, en la representacin interna, termina con un
carcter nulo \0, de tal manera que los programas pueden encontrar el fin, la
longitud de almacenamiento es el nmero de caracteres entre las comillas mas
uno, que es el carcter nulo.
La ms comn ocurrencia de cadenas de caracteres constantes se
encuentra como argumentos de funciones, por ejemplo;
printf(hola, mundo\n);
Cuando una cadena de caracteres, como en el ejemplo anterior, aparece
en un

programa, el acceso a dicha cadena es atraves de un apuntador a

caracteres, la funcin printf recibe un apuntador al inicio de la cadena

de

caracteres, accesando de esta forma al primer elemento de la cadena de

caracteres.
Las cadenas constantes no necesitan ser argumentos de funciones. Si
declaramos una variable apuntador llamada pmensaje como:
char *pmensaje;
Entonces la proposicin:
pmensaje = hola;
Se asigna a pmensaje una puntador al arreglo de caracteres, no es la
copia de la cadena.
Para entenderlo mejor vamos analizar las siguientes definiciones:
char amensaje[]=hola; /*

arreglo

*/

char *pmensaje=hola /* apuntador */

95

la primera expresin declara amensaje como un arreglo, con el tamao

suficiente para contener la cadena de caracteres mas el carcter nulo que lo
finaliza \0, podemos modificar caracteres individuales dentro del arreglo,
amensaje, se referir a la misma localidad de memoria. En cambio pmensaje es
un apuntador, que se inicializ para apuntar a una cadena constante,
posteriormente el apuntador puede modificarse para que apunte a cualquier
otra posicin de memoria.
amensaje

Hola\0

pmensaje

Hola\0

En el lenguaje de programacin C una funcin por s sola no es una

variable, pero se pueden definir apuntadores a funciones, que pueden
asignarse, colocarse en arreglos, pasados y regresados a funciones, etc., esto
debido a que una funcin si bien no es una variable sigue teniendo una posicin
en memoria. A continuacin este apuntador puede ser til para las llamadas a
funciones.

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar y analizar el siguiente ejemplo tomado del libro
Programacin en lenguaje C del autor Herbert Schildt, editorial Mc Graw Hill:
main()
{
int strcmp();

/*declara una funcin */

char s1[80, s2[80];

gets(s1);
gets(s2);

96

comp(s1,s2,strcmp);
}
Comp(a,b,cmp)
Char *a,*b;
Int (*cmp) ();
{
printf(comprueba la igualdad\n);
if (!(*cmp) (a,b)) printf(igual);
else printf(distinto);
}

Este programa utiliza un puntero a funcin, y es na funcin estndar de

comparacin de cadenas que se encuentra en la librera de C. Se declara en
main(), cuando se llama a la funcin comp() se pasan como parmetros dos
caracteres y un puntero a funcin.

6.6 A SIGNACIN

DINMICA D E MEMORIA

Disear un programa de computadora se puede comparar a disear un edificio,

debemos tener presentes diversas consideraciones funcionales y estticas que
contribuyen

al

resultado

final.

Por

ejemplo,

algunos

programas

son

funcionalmente rgidos, como una casa, con un cierto nmero de dormitorios,

una cocina, dos baos, etc. Otros programas tienen que ser abiertos como
centros de convenciones, con paredes mviles y revestimientos modulares que
las permitan adaptarse a diversas necesidades. En este captulo presentamos
los mecanismos de almacenamiento que permiten escribir programas flexibles7.

Nota para una mayor claridad, este tema se tom del libro Programacin Avanzada del

Lenguaje C, de Herbert Schildt, ya que se explica de manera muy concisa.

97

Existen dos formas en las que un programa escrito en lenguaje C

puede almacenar informacin en la memoria principal de la computadora. La
primera utiliza variables locales y globales incluyendo arreglos y estructurasque son definidas por el lenguaje C. Para las variables globales, el
almacenamiento es fijo durante todo el tiempo de ejecucin del programa. Para
las variables locales, el almacenamiento se sita en el espacio de la pila de la
computadora. Aunque las variables globales y locales estn eficientemente
implementadas en C, requieren que el programador conozca de antemano la
cantidad de almacenamiento necesaria en cada situacin
La segunda forma, y la ms eficiente, en la que se puede almacenar la
informacin es utilizando las funciones de asignacin dinmica de memoria del
lenguaje C malloc() y free().
El almacenamiento de la informacin se realiza en el rea de memoria
libre se queda entre el rea de almacenamiento permanente del programa y la
pila (que es utilizada por C para almacenar las variables locales). La figura
siguiente muestra cmo un programa en C aparecera en memoria. La pila
cuando se utiliza crece hacia abajo, de forma que la cantidad de memoria
necesaria est determinada por la forma en que est diseado el programa. Por
ejemplo, un programa con muchas funciones recursivas hace mucho ms
grande la demanda de memoria en pila que un programa que no tiene funciones
recursivas, debido a que las variables locales se almacenan en la pila. La
memoria necesaria para un programa y los datos globales es fija durante la
ejecucin del programa. La memoria para satisfacer una peticin de malloc() se
obtiene del rea de memoria libre, que comienza encima de las variables
globales y crece hacia la pila. Bajo casos bastantes extremos es posible que la
pila se introduzca en la memoria asignada.

Memoria del sistema

Alta

98

pila

Memoria libre para asignacion

Variables globales

Programa
Baja

La utilizacin de la memoria de un programa en C

Si usted no est familiarizado a fondo con malloc() y free(), aqu hay una
pequea revisin.
Una revisin de malloc() y free()
Las funciones malloc() y free() forman el sistema de asignacin
dinmica de memoria del lenguaje C y son parte de la librera estndar de este
lenguaje. Funcionan juntas utilizando la regin de memoria libre que queda
entre el programa y el principio de la pila para establecer y mantener una lista
de almacenamiento disponible. Cada vez que se hace una peticin de memoria
por malloc(), se asigna una porcin de la memoria libre restante. Cada vez que
se hace una llamada para liberar memoria con free() es organizar la memoria
en una lista enlazada.
La funcin malloc() es la funcin de asignacin dinmica de memoria de
propsito general de C. La forma general de llamada es
char *malloc(), *p;
int nmero_bytes;
p=malloc(nmero_bytes);

99

P almacena un puntero al primer byte de la regin de memoria. Si no hay

bastante memoria disponible para satisfacer la peticin de malloc(), ocurre un
fallo de asignacin y malloc() devuelve el valor cero. La funcin malloc()
siempre necesita saber el nmero de bytes que tiene que asignar -incluso si la
informacin que se necesita almacenar es algn otro tipo de datos, tal como un
entero o una estructura-. Se puede utilizar sizeof para determinar el nmero
exacto de bytes necesarios para cada tipo de datos. Esto ayuda a hacer
transportables sus programas a una variedad de sistemas. Incluso aunque se
devuelve un puntero a un carcter, se puede asignar a un puntero del tipo
correcto para satisfacer cualquier necesidad de programacin Antes de utilizar
el puntero devuelto por malloc() siempre asegrese de que la asignacin
pedida tuvo xito comparando el valor devuelto con 0. No utilice un puntero de
valor 0, probablemente colgar el sistema.
La funcin free() es la contraria a malloc(): devuelve al sistema la
memoria previamente asignada. Esta parte de la memoria se puede volver a
utilizar en subsiguientes llamadas a malloc(). La forma general de free() es
char *p; /* asume que p tiene un puntero vlido */
free(p);
Recuerde que nunca se debe llamar a free() con un argumento errneo,
ya que la lista de memoria libre se podra destruir.
El siguiente programa asigna el almacenamiento necesario para 40
enteros, imprime sus valores y libera la memoria al sistema. Aqu sizeof se
utiliza para asegurar la transportabilidad a otros tipos de computadoras.
main ()

/* un corto ejemplo de asignacin */

{
int *p, t;
p=malloc(40*sizeof(int));
if(p==0) {
printf(no hay memoria\n);

100

exit (0);
}
for (t=0;t<40;++t) *(p+t)=t;
for (t=0;t<40;++t) printf (%d ,*(p+t));
free(p9);

101

AUTOEVALUACIN
1. Qu es un apuntador?
Es una variable que contiene una direccin de memoria. Esta direccin es la
posicin de alguna variable en memoria.
2. Suponiendo que n es un entero y p un apuntador a un entero, escribir el
fragmento de cdigo que asignar el valor de 10 a n utilizando el apuntador
p.
p = &n;
*p = 10;
3. Qu operadores aritmticos pueden usarse con los apuntadores?
Solo existen dos operadores aritmticos que se pueden utilizar con los
apuntadores, + y -.
4. Qu funcin tienen malloc() y free() en C.
forman el sistema de asignacin dinmica de memoria del lenguaje C y
son parte de la librera estndar de este lenguaje, malloc() hace una
peticin de memoria y free() es una llamada para liberar memoria.
5. Mencione los operadores especiales sobre apuntadores, y explique su
funcionamiento.
Existen dos operadores especiales sobre apuntadores & y *, ambos son
operadores unarios.
El operador & sirve para dar la direccin de un objeto, y solo se aplica a
objetos que estn en memoria (variables y elementos de arreglos) El
operador * accede al contenido de una variable cuya direccin es el valor de
un puntero.

102

UNIDAD 7
ARCHIVOS Y ENTRADA / SALIDA

OBJETIVO:
El estudiante aprender:
Qu son y cmo funcionan los archivos, as como las principales funciones
utilizadas para su manejo.
Las diferentes funciones de entrada / salida existentes en el lenguaje de
programacin C

TEMARIO
7.1 . DESCRIPTORES DE ARCHIVOS
7.2 E/S DE BAJO NIVEL: READ Y WRITE
7.3 . E/S POR CONSOLA: GETCHAR( ) Y PUTCHAR( ), GETS( ) Y PUTS( )
7.4 E/S POR CONSOLA CON FORMATO PRINTF( ) Y SCANF( )
7.5 MANEJO DE ARCHIVOS
7.5.1 OPEN
7.5.2 CREAT
7.5.3 CLOSE
7.5.4 UNLINK
7.5.5 ACCESO ALEATORIO: LSEEK

103

MAPA CONCEPTUAL

Archivos

Descriptores de
archivos

Entrada / Salida

E/S de Bajo nivel:

E/S por consola:

read, write

get char( ), putchar( )

E/S por consola con

formato:
printf( ), scanf( )

gets( ), puts( )

Manejo de archivos:
open, creat, close, unlink, lseek

104

INTRODUCCIN
El manejo de archivos en C y las funciones de entrada / salida tienen vital
importancia para poder intercambiar informacin con los programas, funcionan
como interfaz entre los programas y el usuario, se analizarn diferentes
funciones de entrada / salida, aprenderemos los descriptores de archivo y cmo
redireccionar las entradas y salidas estndar hacia archivos u otros dispositivos.

El alumno aprender:

Cmo deben manejarse los archivos en C

Las principales funciones de Entrada / Salida que existen en C.

105

7.1 DESCRIPTORES DE ARCHIVOS

Todas las entradas y salidas de datos se realizan por medio de lectura o
escritura de archivos, incluso los dispositivos perifricos como son el teclado y
la pantalla son vistos como archivos que estn en el sistema. Existe una
sencilla interfaz que maneja todas las comunicaciones entre un programa y los
dispositivos perifricos.
Antes de leer o escribir en archivo es necesario informarle al sistema nuestra
intencin de hacerlo, mediante el proceso de abrir un archivo, si se va a escribir
en un archivo, tambin puede ser necesario crear dicho archivo o eliminar el
contenido previo. El sistema verifica si se cuenta con los derechos suficientes
para realizar dichas acciones, por ejemplo:
El archivo existe?
Se cuenta con permisos para tener acceso al archivo?
Si todo es correcto se regresa al programa un entero pequeo no
negativo llamado descriptor de archivo. Siempre que vamos a realizar
operaciones de entrada / salida sobre dicho archivo se utiliza el descriptor de
archivo como identificacin en lugar del nombre de archivo, un descriptor de
archivo es similar al apuntador de archivo usado por la biblioteca estndar.
Toda la informacin referente a un archivo abierto es mantenida por el
sistema, el programa de un usuario hace referencia a los archivos solo por el
descriptor
Debido a que es muy frecuente que tanto la entrada como la salida se
refieran al teclado y a la pantalla, en C existen arreglos especiales para hacer
esto de manera conveniente, cuando el Shell o intrprete de comandos
ejecuta cualquier programa abre tres archivos con descriptores 0, 1 y 2, que son
llamados

entrada

estndar,

salida

estndar

error

estndar

respectivamente, por ejemplo si un programa lee de 0 y escribe en 1 o en 2,

puede hacer operaciones de entrada / salida sin preocuparse de abrir archivos.

106

Para redirigir la entrada / salida estndar hacia o desde un archivo

usando los smbolos: < y >.
prog <archivodeentrada >archivodesalida
En el ejemplo anterior el intrprete de comandos cambia las
asignaciones predefinidas para los descriptores 0 y 1 a los archivos indicados,
en la mayora de los programas dejamos el descriptor de archivo 2 asignado a
la pantalla, para poder visualizar rpidamente los mensajes de error en la
pantalla de la computadora. La asignacin de archivos la cambia el Shell o
interprete de comandos, no el programa.

7.2 E/S

DE BAJO NIVEL : READ Y W RITE .

Desde programas escritos en C se tiene acceso a la entrada y salida por

medio de las funciones read y write, para las cules el primer argumento es un
descriptor de archivo, el segundo argumento es un arreglo de caracteres
perteneciente al programa hacia o de donde los datos van a ir o a venir y el
tercer argumento es el nmero de bytes que sern transmitidos, a continuacin
tenemos dos ejemplos:
int n_leidos = read(int fd, char *buf, int n);
int n_escritos = write(int fd, char *buf, int n);
Cada una de las llamadas regresa una cuenta del nmero de bytes
transferidos, en el proceso de lectura el nmero de bytes regresados puede ser
menor al nmero solicitado, un valor de regreso igual a cero bytes implica fin de
archivo y -1 indica algn tipo de error.
Para la escritura, el valor de retorno es el nmero debytes escritos, si
este no es igual al nmero solicitado ha ocurrido algn error.
En una lectura pueden leerse cualquier cantidad de bytes, sin embargo
los valores mas comnes son:

107

1 significa carcter por carcter a la vez, sin buffer

1024 o 4098 que corresponden al tamao de un bloque fsico de un dispositivo
perifrico, resultando ms eficientes los valores ms grandes debido a que
sern realizadas menos llamadas al sistema.

Actividad de aprendizaje
El estudiante analizar y discutir en clase el siguiente problema tomado del
libro el lenguaje de programacin C, Brian W. Kernighan y Dennis M. Ritchie:
#include syscall.h

main()

/* copia la entrada a la salida */

{
char buf(BUFSIZ);
int n;

while ((n=read(0, buf, BUFSIZ)) > 0)

write(1, buf, n);
return 0;
}

Se han reunido prototipos de funciones para las llamadas al sistema en

un archivo llamado syscall.h, pero este nombre no es estndar.
El parmetro BUFSIZ est definido dentro de syscall.h; su valor es de un
tamao adecuado para el sistema en particular que se utilice

7.3 E/S

POR CONSOLA : GETCHAR (

Y PUTCHAR (

),

GETS (

Y PUTS (

Las funciones de entrada / salida E/S por consola ms simples son:

).

108

getchar() lee un carcter desde la entrada estndar, normalmente asignada al

teclado. Espera a que se pulse una tecla y despus devuelve su
valor, normalmente enva el eco del carcter pulsado a la pantalla,
es decir que el carcter que se oprime en el teclado se mostrar en
la pantalla sin necesidad de indicarlo especficamente.
putchar() imprime un carcter en la salida estndar, normalmente asignada a la
pantalla. Escribe el argumento un carcter en la pantalla de la
computadora, pero solamente si dicho argumento es parte del
conjunto de caracteres que la computadora puede visualizar.

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar el siguiente programa el cul toma caracteres desde el
teclado (entrada estndar) y los mostrar en la pantalla (salida estndar)
cambiando las maysculas por minsculas y viceversa, para finalizar el
programa pulsar un punto . La funcin islower() devuelve cierto si ch
(carcter pulsado en teclado) es un carcter en minscula. La funcin toupper()
convierte una letra minscula en mayscula y la funcin tolower() convertir una
letra mayscula en minscula, ninguna de estas dos funciones afecta a los
caracteres especiales como +, , %, etc. Estas funciones se encuentran en la
librera estndar de C.
main ()

/* cambia tipo de letra maysculas por minsculas y viceversa */

{
char ch;
do {
ch=getchar();
if(islower(ch)) putchar(toupper(ch));

109

else putchar(tolower(ch));
} while (ch!=.);

/* use un punto para parar */

Las funciones que nos permiten leer cadenas de caracteres por consola,
son el siguiente paso en complejidad y potencia son:
Gets() devuelve una cadena terminada con el carcter nulo en el arreglo de
caracteres que recibe como argumento, se pueden teclear caracteres
desde el teclado hasta que se pulse enter, con esto se coloca un
carcter nulo al final de la cadena y gets() devuelve el valor. El enter o
retorno de carro no va en la cadena, por lo que esta funcin no se
puede utilizar para devolver el retorno de carro, sin embargo getchar() si
lo puede hacer. Gets() permite corregir errores de escritura por medio
de la tecla backspace antes de pulsar enter o retorno de carro.
Puts() escribe su argumento de cadena en la pantalla, reconoce los mismos
cdigos de barra invertida que printf(), como puede ser \n para cambio
de lnea. Una llamada a puts() produce menos sobrecarga al
procesador que la llamada a printf(), debido a que solo saca a pantalla
una cadena de caracteres, no puede sacar nmeros o hacer
conversiones de formatos, por esto ocupa menos espacio y es mas
rpida que printf() cuando muestra cadenas en la pantalla, est en la
mayora de las libreras estndar

7.4 E/S

POR CONSOLA CON FORMATO PRINTF (

Y SCANF (

).

Adems de las funciones sencillas de E/S mostradas en los temas anteriores, la

librera estndar de C incluye dos funciones que permiten realizar entrada y

110

salida formateada, la E/S formateada se refiere al hecho de que con estas

funciones se puede formatear la informacin, recordemos que las funciones
descritas anteriormente solo permiten introducir o mostrar los datos en forma de
filas, estas funciones son pritf() y scanf().
printf()
El formato general de esta funcin es:
printf(cadena de control, lista de argumentos);
La cadena de control contiene dos tipos de elementos: el primero est
formado por caracteres que se imprimirn en la pantalla, el segundo tipo
contiene los comandos de formato, que nos sirven para definir la forma en que
se mostrarn en pantalla los siguientes argumentos, debe existir exactamente el
mismo nmero de comandos de formato que de argumentos, los comandos de
formato y los argumentos se aparean por orden.
Por ejemplo:
printf (Hi %c %d %s, c,10,all!);
Mostrar en pantalla:
Hi c 10 all!
La siguiente tabla muestra los cdigos de control de formato de la
funcin printf():
%c

Un nico carcter.

%d

Decimal.

%e

Notacin cientfica.

%f

Coma flotante decimal.

%g

Utiliza %e o %f, la que sea mas corta.

111

%o

Octal.

%s

Cadena de caracteres.

%u

Decimal sin signo.

%x

Hexadecimal.

Estos cdigos de control de formato pueden tener modificadores, por

ejemplo que especifiquen la anchura del campo, el nmero de decimales,
indicador de ajuste a la izquierda. Si colocamos un entero entre el % y el
comando de formateo actuar como un especificador de anchura mnima del
campo, por lo que se rellena la salida con espacios en blanco o con ceros, para
asegunar la longitud mnima, si la cadena o el nmero son mayores que el
nmero mnimo indicado se imprimir entero aunque sobrepase el nmero
mnimo indicado.
Por default siempre el relleno se hace con espacios en blanco, por lo que
si requerimos rellenar con ceros se coloca un 0 delante del especificador de
anchura del campo, por ejemplo: %05d rellenar con ceros los nmeros con
longitud inferior a los 5 dgitos, %10.4f mostrar un nmero de almenos 10
caracteres con cuatro decimales, %5.7s muestra una cadena de caracteres que
tendr al menos cinco caracteres, pero que no exceder de siete.
scanf()
Esta es una rutina de entrada de propsito general, permite leer datos
formateados y convertir automticamente la informacin numrica a enteros o
flotantes, su formato general es:
Scanf(cadena de control, lista de argumentos);
La cadena de control est formada por cdigos de formatos de entrada,
como se muestra en la siguiente tabla:

112

%c

Lee un nico carcter.

%d

Lee un entero decimal.

%e

Lee un nmero en punto flotante.

%f

Lee un nmero en punto flotante.

%h

Lee un entero corto.

%o

Lee un nmero octal.

%s

Lee una cadena de caracteres.

%x

Lee un nmero hexadecimal.

Los comandos de formato pueden utilizar modificadores de la longitud de

campo, como en el caso de printf() son enteros que se colocan entre el % y el
cdigo de comando de formato, un * colocado despus del % suprimir la
asignacin y avanzar a la siguiente entrada del campo.
Todas las variables utilizadas para recibir valores por medio de esta
funcin se pasan por sus direcciones, por lo que todos los argumentos, distintos
a los de la cadena de control, tienen que apuntar a las variables que recibirn la
entrada, por ejemplo:
scanf(%d,&cuenta);
Lee un entero dentro de la variable cuenta.
Las cadenas de caracteres se leern sobre arreglos de caracteres, por
ejemplo para leer una cadena dentro del arreglo de caracteres direccin,
utilizamos:
scanf(%s,direccin);
En este ejemplo direccin ya es un apuntador y no es necesarios que
vaya precedido por el operador &.

113

Si se tiene cualquier otro carcter en la cadena de control, incluyendo

espacios en blanco, tabuladores y cambios de lnea, se utilizarn para
comprobarlos con los caracteres del flujo de entrada, cualquier carcter que se
aparee con ellos ser descartado, ver el segundo ejemplo indicado a
continuacin.
Ejemplos de scanf()
Para el flujo de entrada: x y,
scanf(%c%c%c,&a,&b,&c);
asignar el carcter x a la variable a, un espacio en blanco a la variable b
y el carcter y en la variable c.
Para el flujo de entrada abcdttttttefg,
scanf(st%s,nombre1,nombre2);
asignar los caracteres abcd en nombre1 y los caracteres efg en
nombre2, las letras t

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar al menos 10 ejemplos ms de formatos con la funcin
printf() y 10 ms con la funcin scanf()

7.5 M ANEJO

DE ARCHIVOS .

A continuacin se describen las funciones principales existentes en C para el

manejo de archivos.

114

7.5.1 Open
Esta funcin regresa un descriptor de archivo que es tan solo un int, regresa -1
si ocurrea lgn error.
include <fcntl.h>
int fd;
int open(char *nombre, int flags, int perms);
fd=open(nombre,flags,perms);
El argumento nombre es una cadena de caracteres que contiene el
nombre del archivo, el segundo argumento (flags) es un int que especifica como
se debe abrir el archivo:
O_READONLY abrir solo para lectura.
O_WRONLY abrir solo para escritura.
O_RDWR abrir tanto para lectura como para escritura.
Estas constantes estn definidas en <fcnl.h> cuando usamos, por
ejemplo UNIX System V, y en <sys/file.h> en otros sistemas, por ejemplo Unix
con Berkeley (BSD).
Ejemplo:
Abrir un archivo ya existente para lectura:
fd = open(nombre, O_RDONLY,0);

7.5.2 Creat
Sera un error tratar de abrir un archivo que no exista, con la instruccin de
arriba, para poder crear nuevos archivos o reescribir archivos viejos, se utiliza la
llamada al sistema creat:
int creat(char *nombre,int perms);

115

fd = creat(nombre, perms);
Esta funcin regresa un descriptor de archivo si pudo crear el archivo, y
un -1 si no pudo ser creado.
Si el archivo ya existe, esta funcin lo truncar a longitud cero,
descartando su contenido previo, no significa un error crear con creat un archivo
existente, en caso de que no exista creat lo crea con los permisos que
especificamos con el argumento perms.
En sistemas de archivos con el SO UNIX hay 9 bits para informacin de
permisos asociados con archivos, que nos permiten controlar el acceso de
lectura, escritura y ejecucin tanto para el propietario del archivo, para el grupo
del propietario y para el resto de los usuarios que tengan acceso al archivo. Por
esto un nmero octal de 3 dgitos es apropiado para especificar los permisos de
acceso a un archivo, por ejemplo 0755, especifica permisos para leer, escribir y
ejecutar solo para el propietario del archivo y de lectura y ejecucin para el
grupo al que pertenece el propietario y para todos los dems usuarios.
7558 = 111 101 1012
El grupo de 3 bits de la derecha hacen referencia al propietario, el del
centro al grupo de usuarios del propietario y el de la derecha al resto de
usuarios.
Cada bit puede brindar si su valor es 1 un permiso o negarlo si su valor
es 0, cada grupo de 3 bits proporciona permisos de lectura, escritura y
ejecucin respectivamente de derecha a izquierda.

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar y analizar el siguiente programa en C que le permite
copiar un archivo a otro.

116

#include <stdio.h>
#include <fcntl.h>
#include syscall.h
#define PERMS 0666

/* lectura y escritura para propietario, grupo y otros */

void error(char *,);

/* cp: copia f1 a f2 */
main(int argc, char *argv[])
{
int f1, f2, n;
char buf[BUFSIZ];

if(arg = 3)
error (uso: cp de hacia);
if((f1 = open(argv[1], O_RDONLY, 0)) == -1)
error(cp: no se puede abrir %s, argv[1]);
if((f2 = creat(argv[2],PERMS)) == -1)
error(cp:

no

se

puede

crear

%s,

modo

%03o,

argv[2],PERMS);
while((n = read(f1, buf, BUFSIZ)) > 0)
if (write(f2, buf, n) != n)
error(cp: error de escritura en archivo %s, argv[2]);
return 0;
}

Este programa crea el archivo de salida con permisos fijos O666, se

podra utilizar el la llamada al sistema stat para determinar el modo de un
archivo existente para dar el mismo modo a la copia.
El estudiante investigar cmo funciona la llamada al sistema stat.

117

7.5.3 Close
Existe un lmite en el nmero de archivos que un programa en C puede tener
abiertos simultneamente, comnmente de 20. Por esta razn es muy
importante la siguiente funcin, cuya sintaxis es:
close(int fd)
Esta funcin suspende la conexin entre un descriptor de archivo y un
archivo abierto, liberando al descriptor de archivo para que pueda ser utilizado
por otro archivo. Es muy similar a la funcin fclose de la biblioteca estndar,
pero no existe un buffer que vaciar. La funcin exit o return desde el programa
principal cierra todos los archivos abiertos,

7.5.4 Unlink
La sintaxis de esta funcin es:
unlink(char *nombre)
remueve el archivo nombre del sistema de archivos.
Corresponde a la funcin remove de la biblioteca estndar.

7.5.5 Acceso aleatorio: Lseek

Normalmente tanto la entrada como la salida son secuenciales, pero C
tambin soporta archivos de E/S de acceso aleatorio mediante el sistema de
E/S/ de bajo nivel mediante llamadas a lseek(), su formato general es el
siguiente:
int fd, origen;
long desplazamiento;
lseek(fd, desplazamiento, origen);

118

En donde fd es un descriptor de archivo devuelto al llamar a creat() o a

open().
La forma en que trabaja depende de los valores del origen y del
desplazamiento. El origen puede ser 0, 1 o 2, en la siguiente tabla se especifica
cmo se interpreta el desplazamiento para cada uno de estos 3 valores:

Origen
0
1
2

Efecto al llamar a lseek()

Cuenta el desplazamiento desde el
principio del archivo.
Cuenta el desplazamiento desde la
posicin actual del archivo.
Cuenta el desplazamiento desde el
final del archivo.

ACTIVIDAD DE APRENDIZAJE
El estudiante realizar un programa para leer archivos, la finalidad de dicho
programa debe ser definida por el profesor.

119

AUTOEVALUACIN
1. Menciona 3 funciones tiles en el manejo de archivos.
open, close, creat, unlink.
2. Cules son los dispositivos estndar para la entrada y salida?
El teclada para la entrada y la pantalla para la salida.
3. Qu es un descriptor de archivo?
Siempre que vamos a realizar operaciones de entrada / salida sobre un
archivo se utiliza el descriptor de archivo como identificacin en lugar del
nombre de archivo, un descriptor de archivo es similar al apuntador de
archivo usado por la biblioteca estndar.
4. Escribir una llamada a scanf() para que introdusca una cadena de
caracteres y dos nmeros enteros.
scanf(%s%d%d, s, d1, d2);
5. Escribir una llamada a printf() que muestre en pantalla por lo menos 5
caracteres, pero no mas de 10, para cada uno de los siguientes tipos de
datos: entero, cadena de caracteres, y flotante.
printf(%5.10d %5.10s %5.10f, dec, string, flt);

120

BIBLIOGRAFA

El Lenguaje de Programacin C, Brian W. Kernighan, Dennis M. Ritchie,

Prentice-Hall Hispanoamericana, S.A., Segunda Edicin, Mxico 1988

Lenguaje C Programacin Avanzada, Herbert Schildt, Mc Graw Hill,

Mxico, 1990

Metodologa de la Programacin, Luis Joyanes Aguilar, Mc Graw Hill,

Mxico,1987

Programacin en Lenguaje C, Herbert Schildt, Mc Graw Hill, Mxico,

1990

121

GLOSARIO
Acceso Aleatorio: en computacin es la habilidad que se tiene para acceder a
un elemento arbitrario de una secuencia de datos, no requiere haber accesado
al elemento previo.
Apuntadores: variable existente que hace referencia a una direccin fsica de
memoria de una computadora
Archivo: es un conjunto de bits almacenado en un dispositivo perifrico de una
computadora.
Arreglos: tabla de una o ms dimensiones que permite almacenar de manera
ordenada informacin en una computadora.
Bit: acrnimo de Binary Digit, es un dgito del sistema de numeracin binario,
solo puede tener dos valores 0 o 1, es la unidad bsica de informacin en una
computadora.
Byte: Secuencia de bits contiguos, en muchas ocasiones conjunto de 8 bits, es
la unidad bsica de almacenamiento en una computadora.
Compilar: Traducir un programa escrito en un lenguaje de programacin
generalmente de alto nivel a cdigo de mquina que puede ser interpretado por
una computadora.
Constante: es un valor que no puede ser alterado durante la ejecucin de un
programa.
Funcin: es un subprograma que sirve para resolver una tarea especfica, en
programacin son subrutinas que devuelven un valor.
Ligar: tomar los programas en cdigo objeto o de mquina generado por un
compilador para unirlo con todos los cdigos de funciones, subrutinas, etc.
almacenados en las libreras para generar el cdigo ejecutable de un programa.

122

Operador: es un smbolo matemtico que indica que debe ser llevada a cabo
una operacin especfica sobre un cierto nmero de operandos.
Recursividad: es la forma en la cual se especifica un proceso basado en su
propia definicin, en programacin es un proceso que dentro de su definicin
hace llamada a el mismo.
Variable: es un smbolo que representa un elemento no especificado de un
conjunto dado, en programacin es una zona de memoria que puede tomar
diversos valores durante la ejecucin de un programa.