PROGRAMACIN

PROGRAMACIN
EN
EN
LENGUAJE C
LENGUAJE C
Managua, Nicaragua
INDICE
Objetivos del mdulo.................................................................................................................. 2
ntroduccin al mdulo................................................................................................................ 2
Parte I
Unidad 1:.Introduccin
1.1 ntroduccin.......................................................................................................................... 2
1.2 Breve Resea Histrica....................................................................................................... 3
1.3 Estructura de los programas en C....................................................................................... 3
1.4 Conceptos Bsicos.............................................................................................................. 5
1.5 Tipos de datos..................................................................................................................... 6
1.6 Resumen............................................................................................................................. 7
1.7 Autoevaluacin.................................................................................................................... 7
Unidad !: Con"tante", #aria$%e", O&eradore", e'&re"ione" ( )uncione" de $i$%ioteca
2.1 ntroduccin.......................................................................................................................... 9
2.2 Variables. ............................................................................................................................. 9
2.3 Constantes ........................................................................................................................ 12
2.4 Operadores ....................................................................................................................... 15
2.5 Expresiones....................................................................................................................... 21
2.6 Sentencias......................................................................................................................... 22
2.7 Funciones de Biblioteca..................................................................................................... 24
Unidad *: Entrada ( +a%ida de dato"
3.1 ntroduccin........................................................................................................................ 25
3.2 Funcin pritnf...................................................................................................................... 25
3.3 Funcin scanf..................................................................................................................... 27
3.4 Autoevaluacin................................................................................................................... 31
Unidad ,:E"tructura" de "e%eccin
4.1 ntroduccin....................................................................................................................... 33
4.2 Simples (if)......................................................................................................................... 34
4.3 Dobles (if-else)................................................................................................................... 34
4.4 Compuestas (Switch-case)................................................................................................ 37
4.5 Autoevaluacin................................................................................................................... 39
Unidad -: +entencia" de contro%
5.1 ntroduccin........................................................................................................................ 41
5.2 Sentencia Cclicas while..................................................................................................... 41
5.3 , Sentencia Cclicas do....................................................................................................... 43
5.4 Sentencia Cclicas for......................................................................................................... 45
5.5 Sentencias break y continue............................................................................................... 48
Parte II
Unidad 1: .uncione"
1.1 Concepto de funciones...................................................................................................... 50
1.2 Estructura de una funcin.................................................................................................. 50
1.2.1 Definicin de la Funcin......................................................................................... 50
1.2.2 Llamadas a la funcin............................................................................................ 52
1.2.3 Prototipos de funciones.......................................................................................... 52
1.3 mbito de la Variables....................................................................................................... 55
1.3.1 Variables Globales................................................................................................. 55
1.3.2 Variables Locales................................................................................................... 56
1.3.3 Variables Locales Estticas................................................................................... 57
1.4 Concepto y uso de funciones matemticas de biblioteca..................................................59
1.5 Recursividad...................................................................................................................... 59
1.6 Resumen........................................................................................................................... 60
1.7 Autoevaluacin.................................................................................................................. 60
2
Unidad !: Arreg%o"
2.1 ntroduccin........................................................................................................................ 62
2.2 Concepto de arreglos......................................................................................................... 63
2.3 Arreglos Unidimensionales ................................................................................................ 63
2.4 nicializacin de un arreglo................................................................................................. 65
2.5 Arreglos de caracteres y/o cadenas de texto......................................................................66
2.6 Arreglos multidimensionales............................................................................................... 67
2.7 Utilizacin de arreglos como parmetros............................................................................ 68
2.8 Resumen............................................................................................................................ 69
2.9 Autoevaluacin................................................................................................................... 72
Unidad *: E"tructura" ( Unione"
3.1 ntroduccin........................................................................................................................ 74
3.2 Definicin de Estructura...................................................................................................... 74
3.3 nicializacin de Estructuras............................................................................................... 76
3.4 Acceso a los miembros de Estructuras............................................................................... 76
3.5 Arreglos de estructuras....................................................................................................... 78
3.6 Estructuras anidadas.......................................................................................................... 80
3.7 Utilizacin de estructuras como parmetros.......................................................................83
3.8 Concepto de Unin ............................................................................................................ 85
3.9 Concepto de Enumeracin................................................................................................. 86
3.8 Ejemplos de programas que utilizan Uniones y Enumeraciones........................................87
3.4 Autoevaluacin................................................................................................................... 87
Unidad ,: Puntero"
4.1 Conceptos de Punteros...................................................................................................... 92
4.2 Declaracin de Punteros.................................................................................................... 92
4.3 Punteros y Arreglos........................................................................................................... 93
4.4 Paso de a Punteros a Funciones........................................................................................ 95
4.5 Aritmtica de Punteros...................................................................................................... 96
4.6 Arreglos de Punteros......................................................................................................... 97
4.7 Resumen............................................................................................................................ 99
4.8 Autoevaluacin................................................................................................................. 100
Lecturas Adicionales............................................................................................................... 103
3
I. OBJETIVOS DEL MDULO
Este mdulo tiene como objetivo principal introducir al alumno en las tcnicas bsicas de programacin de
computadoras, utilizando el Lenguaje C como lenguaje de programacin.
II. INTRODUCCION
El lenguaje de programacin C est caracterizado por ser de uso general, con una sintaxis sumamente compacta y de
alta portabilidad, de fcil aprendizaje.
Es comn leer !ue se lo caracteriza como un lenguaje de "bajo nivel". #o debe confundirse el trmino "bajo" con "poco",
ya !ue el significado del mismo es en realidad "profundo", en el sentido !ue C maneja los elementos bsicos presentes
en todas las computadoras$ caracteres, nmeros y direcciones.
Esta particularidad, junto con el %ec%o de no poseer operaciones de entrada&salida, manejo de arreglo de caracteres, de
asignacin de memoria, etc , puede al principio parecer un grave defecto' sin embargo el %ec%o de !ue estas
operaciones se realicen por medio de llamadas a (unciones contenidas en Librer)as externas al lenguaje en s), es el !ue
confiere al mismo su alto grado de portabilidad, independizndolo del "*ard+are" sobre el cual corren los programas,
como se ir viendo a lo largo del aprendizaje de este novedoso lenguaje de programacin ,asignaturas de -rogramacin
. y -rogramacin ../.
La descripcin del lenguaje se realiza siguiendo las normas del 0#1. C, por lo tanto, todo lo expresado ser utilizable
con cual!uier compilador !ue se adopte' sin embargo en algunos casos particulares se utilizaron funciones Compilador
1istema 2perativo&dependientes, explicitndose en estos casos la singularidad de las mismas.
4
I PARTE
Unidad 1: Introduccin
O!"#ti$o:
a/ .ntroducir los elementos principales de la programacin en lenguaje C.
b/ Cubrir gran parte de las caracter)sticas del lenguaje, as) como algunas funciones de las bibliotecas estndares.
Cont#nido%:
3.4 .ntroduccin
3.5 6reve 7ese8a *istrica
3.9 Estructura de los programas en C
3.: Conceptos 6sicos
3.:.3 Conjunto de caracteres de C
3.:.; .dentificadores
3.:.< palabras claves
3.3= >ipos de datos
3.33 7esumen
3.3; 0utoevaluacin
1.1 INTRODUCCION
El procesador debe ser capaz de interpretar el algoritmo !ue significa$
Comprender las instrucciones de cada paso
7ealizar las operaciones correspondientes
Cuando el procesador es una computadora, el algoritmo se %a de expresar en formato !ue se denomina programa. ?n
&ro'ra(a se escribe en un lenguaje de programacin y las operaciones !ue conduce a expresar un algoritmo en forma
de programa se llama programacin. 0s), pues, los lenguajes utilizados para escribir programas de computadoras son
los lenguajes de programacin y programadores son los escritores y dise8adores de programas.
Los principales tipos de lenguajes utilizados en la actualidad son tres$
Lenguajes de m!uinas
Lenguajes de bajo nivel ,ensamblador/
Lenguajes de alto nivel
Lenguaje de m!uina
Los lenguajes de m!uinas son a!uellos !ue estn escritos en lenguajes directamente inteligibles por la m!uina
,computadora/, ya !ue sus instrucciones son cadenas binarias ,cadenas o series de caracteres @d)gitos @ = y 3/ !ue
especifican una operacin, y las posiciones de memoria implicadas en la operacin se denominan instrucciones de
m!uina o cdigo de m!uina.
Lenguajes de bajo nivel
Los lenguajes de bajo nivel son ms fciles de utilizar !ue los lenguajes de m!uina, pero, al igual, !ue ellos, dependen
de la m!uina en particular. El lenguaje de bajo nivel por excelencia es el #n%a(!)ador.
Lenguaje de alto nivel
Los lenguajes de alto nivel son los ms utilizados por los programadores. Estn dise8ados para !ue las personas
escriban y entiendan los programas de un modo ms fcil !ue los lenguajes de m!uinas y ensambladores. 2tra razn
es !ue el lenguaje de alto nivel es independiente de la m!uina' esto es, las instrucciones del programa de la
computadora no dependen del dise8o del %ard+are o de una computadora en particular.
5
1.* Br#$# R#%#+a ,i%trica
En este apartado el estudiante deber realizar una investigacin y presentar un informe sobre este tema.
1.- E%tructura d# )o% &ro'ra(a% #n C
>odo programa en C consta de una o ms funciones, una de las cuales se llama main. El programa siempre comenzar
por la ejecucin de la funcin main. Cada funcin debe contener$
a. una cabecera de la funcin, !ue consta del nombre de la funcin, seguido de una lista opcional de argumentos
encerrados con parntesis.
b. ?na sentencia compuesta, !ue contiene el resto de la funcin.
Los argumentos son s)mbolos !ue representan informacin !ue se le pasa a la funcin desde otra parte del programa.
>ambin se llaman parmetros a los argumentos/.
Cada sentencia compuesta se encierra con un par de llaves Ay B. Las llaves pueden contener combinaciones de
sentencias elementales ,denominadas sentencias de expresin/ y otras sentencias compuestas. 0s) las sentencias
compuestas pueden estar anidadas, una dentro de otra. Cada sentencia de expresin debe acabar con un punto y coma
,'/.
Los comentarios pueden aparecer en cual!uier parte del programa, mientras estn situados entre los delimitadores CD y
DC. Los comentarios son tiles para identificar los elementos principales de un programa o para la explicacin de la lgica
subyacente de stos.
EJEMPLO
El siguiente es un programa en C elemental !ue lee el radio de un c)rculo, calcula el rea y escribe el resultado
calculado.
Einclude Fstdio.%G CD0cceso al arc%ivo de biblioteca DC
CD -rograma !ue calcula el rea de un c)rculo . ./>)tulo ,comentario/DC
main,/ CDCabecera de la funcin DC
A
float radio, area' CD Heclaracin de las variables DC
printf,I7adio J KL/' CD 1entencia de salida DC
scanf,IMfL, Nradio/' CD 1entencia de entrada DC
area J <.3O3P: D radio D radio' CD 1entencia de asignacin DC
prirntf ,IQrea J Mf L, area/' CD 1entencia de salida DC
B
S# d#!# 0ac#r (#ncin a )o% %i'ui#nt#% &unto%:
3. El programa est escrito en minscula sin acentuar ,salvo los comentarios/. 1e pueden usar maysculas o
minscula ,las letras maysculas y minsculas no son e!uivalentes en C/.
;. La primera l)nea contiene una referencia a un arc%ivo especial ,stdio.%/ !ue contiene informacin !ue se incluir
,include/ en el programa cuando se compila..
<. La segunda l)nea es un comentario !ue describe el propsito del programa.
O. La tercera l)nea es la cabecera de la funcin. Los parntesis vac)os !ue siguen al nombre de la funcin indican !ue
sta no incluye argumentos.
P. Las cinco l)neas restantes del programa estn adentradas ,con tabuladores/ y encerradas en un par de llaves.
Estas cinco l)neas integran la sentencia compuesta dentro de main.
4. La primera l)nea adentrada es una declaracin de variables. Establece los nombres simblicos de radio y area
como variables de coma flotante.
6
5. Las otras cuatro l)neas adentradas son un tipo particular de sentencia de expresin. La segunda l)nea adentrada
,printf/ genera una solicitud de informacin ,el valor del radio/. Este valor se introduce en la computadora al
ejecutarse la tercera l)nea adentrada ,scanf/.
9. La cuarta l)nea adentrada es un tipo particular de sentencia de expresin llamada sentencia de asignacin. Esta
sentencia %ace el clculo del rea a partir del valor del radio dado.
:. La ltima l)nea adentrada ,printf/ presenta el valor calculado del rea. El valor numrico ser precedido por un
breve mensaje ,IQrea J L/.
3=. Cada sentencia de expresin dentro de la sentencia compuesta finaliza con un punto y coma.
1.1 Conc#&to% !2%ico%
1.1.1 Con"unto d# caract#r#% d# C
En la redaccin de programas en C se pueden utilizar para formar los elementos bsicos ,constantes, variables,
operadores, expresiones/ las letras maysculas y minsculas de la a a la z, los d)gitos del = al : y ciertos caracteres
especiales. 1e presenta a continuacin una lista de estos caracteres especiales$
R D S I F
E , J A G
M / T ' C
U & V $ K
N W X . ,blanco/
B Y , L
1.1.*. Id#nti3icador#%
Los identificadores son nombres !ue se les da a varios elementos de un programa, como variables, funciones y arrays.
?n identificador est formado por letras y d)gitos, en cual!uier orden, excepto el primer caracter, !ue debe ser una letra.
1e pueden utilizar maysculas y minsculas ,no acentuadas/, aun!ue se acostumbra utilizar minsculas. #o se pueden
intercambiar maysculas y minsculas, esto es, una letra mayscula no es e!uivalente a su correspondiente minscula.
El caracter de subrayado ,W/ se puede incluir tambin, y es considerado como una letra. 1e acostumbra a utilizar este
caracter en mitad de los identificadores. >ambin se puede comenzar con un caracter de subrayado.
Ejemplo de identificadores vlidos Ejemplo de identificadores invlidos
Z nombres Oletras suma de enteros
1umaW3 Wtemperatura suma&3 IxL
1.1.- Pa)a!ra% C)a$#%
Existen ciertas palabras reservadas, !ue tienen en C un significado predeterminado. Estas slo se pueden utilizar para
su propsito ya establecido' no se pueden utilizar como identificadores definidos por el usuario.
Las palabras claves son$
auto brea[ case c%ar
const continue default do
double else enum extern
float for goto if
int long register return
s%ort signed sizeof static
struct s+itc% typedef union
unsigned void volatile +%ile
7
Existen algunos compiladores !ue incluyen todas o algunas de las siguientes palabras claves$
ada far near asm
fortran pascal entry %uge
1.4 Ti&o% D# Dato%
Existen en C distintos tipos de datos, cada uno de los cuales se puede encontrar representado de forma diferente en la
memoria de la computadora. 0 continuacin se presenta una lista de los tipos de datos bsicos. >ambin se presentan
los re!uerimientos de memoria t)picos. ,El re!uerimiento de memoria para cada tipo de datos numrico determinar el
rango permisible de valores para ese tipo de datos. *ay !ue se8alar !ue los re!uerimientos de memoria para cada tipo
de datos pueden variar de un compilador de C a otro./
Ti&o d#
Dato%
D#%cri&cin R#5u#ri(i#nto T6&ico d# M#(oria
int Cantidad Entera ; bytes o una palabra ,var)a
de un compilador a otro/
c%ar Carcter 3 byte
float #mero de coma flotante ,!ue incluye punto decimal yCo
exponente/
3 palabra O bytes
double #mero de coma flotante de doble precisin ,ms cifras
significativas y mayor valor posible del exponente/
; palabras ,9 bytes/
Los compiladores de C dise8ados para computadoras personales o minicomputadoras pe!ue8as ,computadoras con
longitud de palabra menor de <; bits/ representan generalmente una palabra con O bytes ,<; bits/.
0lgunos tipos bsicos de datos se pueden ampliar utilizando los cualificadores de tipos de datos %0ort ,corto/, )on'
,largo/, %i'n#d ,con signo/ y un%i'n#d ,sin signo/. -or ejemplo se pueden definir cantidades numricas como s%ort int,
long int o unsigned int ,estos tipos de datos se suelen escribir simplemente s%ort, long o unsigned, y se supone !ue son
enteros/. ?n s%ort int re!uerir menos memoria o la misma !ue un int ordinario, pero nunca ms. He igual forma, un
long int puede re!uerir la misma cantidad de memoria o ms !ue un int ordinario, pero nunca una cantidad de memoria
menor.
1i s%ort int e int re!uieren la misma memoria ,por ejemplo ; bytes/, entonces long int, generalmente, ocupar el doble
,por ejemplo O bytes/.
?n unsigned int ocupa la misma memoria !ue un int ordinario, con la diferencia de !ue en el caso de un int ordinario ,o
un s%ort int o un long int/, el bit ms a la iz!uierda se reserva para el signo. En un unsigned int, todos los bits se utilizan
para representar el valor numrico. He esta forma, un unsigned int puede llegar a almacenar un valor numrico
aproximadamente el doble !ue in int ordinario ,aun!ue, por supuesto, no puede almacenar valores negativos/.
R#%u(#n
Los lenguajes de programacin son %erramientas !ue nos permiten crear programas y soft+are. ?na computadora
funciona bajo control de un programa el cual debe estar almacenado en la unidad de memoria' tales como el disco duro,
o dis!uete.
Los lenguajes de programacin facilitan la tarea de programacin, ya !ue disponen de formas adecuadas !ue permiten
ser le)das y escritas por personas, a su vez resultan independientes del modelo de computador a utilizar.
Los lenguajes de programacin representan en forma simblica y en manera de un texto los cdigos !ue podrn ser
le)dos por una persona.
8
1.7 Auto#$a)uacin
3. Encuentre el error en cada uno de los siguientes enunciados, si los %ubiese.
a/ CD este es un comentario corto DC
b/ CD este otro
es muc%o
ms largo
!ue el anterior CD
c/ Einclude Fstdio.%G
\0.#,/
A
printf,"%ello, "/
printf,"+orld "/
printf,"Sn"/
B
;. ]u tipo de datos resulta ms adecuado para representar cada uno de los conceptos siguientes $
a/ El sueldo de un trabajador
b/ La edad de una persona
c/ El nmero de %ijos
d/ El estado civil
e/ El estado de caducado no de un producto
f/ El n^ de telfono
g/ La direccin
9
Unidad !: Con"tante", #aria$%e", O&eradore", e'&re"ione" ( )uncione" de
$i$%ioteca
O$/eti0o:
a) Dominar el concepto de variable y su respectiva declaracin
b) Conocer los diferentes tipos de constantes en C
c) Conocer los operadores de C
d) Disear expresiones vlidas en C
CON1ENIDO
2.1 ntroduccin
2.2 Variables.
2.2.1 Declaracin de variables.
2.2.2 nicializacin de variables.
2.2.3 Modos de almacenamiento
2.3 Constantes
2.3.1 Constantes enteras
2.3.2 Constantes reales en coma flotante.
2.3.3 Constantes carcter.
2.3.4 Constantes cadena de caracteres
2.3.5 Constantes simblicas
2.4 Operadores
2.4.1 Operadores aritmticos
2.4.2 Operadores relacionales y lgicos
2.4.3 Operadores de incremento y decremento
2.4.4 Operadores y expresiones de asignacin
2.4.5 Conversiones de tipo
2.4.6 Precedencia y orden de evaluacin
2.5 Expresiones
2.6 Sentencias
2.7 Funciones de Biblioteca
!.1 Introduccin
!.! #aria$%e"
Una variable es un identificador que se utiliza para representar cierto tipo de
informacin dentro de una determinada parte del programa. En su forma ms
sencilla, una variable contendr un dato simple, esto es, una cantidad numrica o
una constante de carcter. En algn punto del programa se le asignar a la
variable un determinado valor. Este valor se puede recuperar despus en el
programa con simplemente hacer referencia al nombre de la variable.
10
A una variable se le puede asignar diferentes valores en distintas partes del
programa, de esta forma la informacin representada por la variable puede
cambiar durante la ejecucin del programa. Sin embargo, el tipo de datos
asociado a la variable no puede cambiar.
E/e2&%o: Un programa en C contiene las siguientes Lneas:
int a, b, c;
char d;
. . .
a=3;
b=5;
c=a+b;
d='a';
. . .
a=4;
b=2;
c=a-b;
d='W';
El array (arreglo) es otra clase de variable que se utiliza con frecuencia en C. Un
array es un identificador que referencia una coleccin de datos. Cada uno de
estos datos es representado por su elemento del array correspondiente (por
ejemplo, el primer dato es representado por el primer elemento del array y as
sucesivamente). Los elementos individuales del array se distinguen unos de otros
por el valor que se le asigna al ndice.
E/e2&%o: Supongamos que x es un array de 10 elementos. El primer elemento es
x[0], el segundo x[1], y as sucesivamente. El ltimo elemento ser x[9].
El ndice asociado a cada elemento se encierra entre corchetes. De esta forma, el
valor del ndice para acceder al primer elemento es 0, para acceder al segundo
elemento 1, y as sucesivamente. Para un array de n elementos, los valores del
ndice se encontrarn entre 0 y n-1.
Hay diferentes tipos de arrays (arrays de enteros, arrays de caracteres, arrays
unidimensionales, arrays multidimensionales...).
!.!.1 Dec%aracin de 0aria$%e"
Una declaracin asocia un tipo de datos determinado a un grupo de variables. Se
deben declarar todas las variables antes de que aparezcan sentencias
ejecutables.
Una declaracin consiste en un tipo de datos, seguido de uno o ms nombres de
variables, finalizando con un punto y como (;).
E/e2&%o 1: Un programa en C contiene las siguientes declaraciones de tipos:
11
int a, b, c;
float raiz1, raiz2;
char indicador, texto[80];
Las variables de tipo entero se pueden declarar como enteros cortos para
pequeas cantidades enteras, o enteros largos para cantidades enteras mayores.
Estas variables se pueden declarar escribiendo short in y long int, o simplemente
short y long respectivamente.
E/e2&%o !:
short int a, b, c;
long int r, s, t;
int p,q;
E/e2&%o *:
#include <stdio.h>
main()
{
float cels, farh;
farh = 35.0;
cels = 5.0 * ( farh - 32.0 ) / 9.0;
printf(">>> %f f son %f c\n", farh, cels );
}
En el programa anterior se definen dos variables float, se asigna un valor a la
primera y se calcula la segunda mediante una expresin aritmtica. En la
instruccin printf, el smbolo %f indica que se imprime un nmero en coma
flotante.
!.!.! Inicia%i3acin de 0aria$%e".
Se le pueden asignar valores iniciales a las variables dentro de la declaracin de
tipo. Para hacer esto, la declaracin debe consistir en un tipo de datos, seguido
por un nombre de variable, un signo igual (=) y una constante del tipo apropiado.
Al final se debe poner punto y coma (;).
Ejemplo:
int c=12;
char estrella='*';
float suma=0.;
double factor=0.21023e-6;
12
!.!.* Modo" de a%2acena2iento
4Dnde "e dec%aran %a" 0aria$%e"5
Tenemos dos posibilidades, una es declararla como g%o$a% y otra como %oca%. Es
global aquella variable que se declara fuera de la funcin main y local la que se
declara dentro:
Variable Global Variable Local
#include <stdio.h>
int x;
int main() {
}
#include <stdio.h>
int main() {
int x;
}

Las variables globales se pueden usar en cualquier funcin y las locales slo
pueden usarse en la funcin en el que se declaran. Es buena costumbre usar
variables locales en vez de globales.
!.* Con"tante"
C tiene cuatro tipos bsicos de constantes: constantes enteras, constantes de
coma flotante, constantes de carcter y constantes de cadena de caracteres.
Las constantes enteras y de coma flotante representan nmeros. Se las
denomina, en general, constantes de tipo numrico. Las siguientes, reglas se
pueden aplicar a todas las constantes numricas:
1- No se pueden incluir comas ni espacios en blanco en la constante.
2- Si se desea, la constante puede ir precedida de un signo menos (-).
3- El valor de una constante no puede exceder un lmite mximo y un mnimo
especificados.
!.*.1 Con"tante" entera"
Una constante entera es un nmero con un valor entero, consistente en una
secuencia de dgitos. Las constantes enteras se pueden escribir en tres sistemas
numricos diferentes: decimal (base 10), octal(base 8) y hexadecimal (base 16).
En decimal (nmero que no empieza por 0), octal (el primer dgito es 0) y hexa
(comienza con 0x 0X). Adems pueden ser con signo o sin signo. Si es sin
13
signo se les aade el sufijo U. El tamao de las constantes puede ser normal o
largo, en este caso se aade el sufijo L.
E/e2&%o:
Constantes enteras decimales correctas
0 1 743 5280 32767 9999
Constantes enteras decimales incorrectas
12,245 36.0 10 20 30 123-45-6789 0900
!.*.! Con"tante" rea%e" en co2a )%otante.
Una constante de coma flotante es un nmero en base 10 que contiene un punto
decimal o un exponente (o ambos).
E/e2&%o:
Constantes de coma flotante correctas Constantes de coma flotante incorrectas
0. 50000. 2E-8 1. 0.2 827.602 1 1,000.0 2E+10.2 3E 10
!.*.* Con"tante" car6cter.
Es un slo carcter o una secuencia de escape encerrado con comillas simples.
E/e2&%o: 'A' 'x' '3' '$' ' '
Alguna de las secuencias de escape son:

sonido (campana) '\a'
Backspace '\b'
tab horizontal '\t'
nueva lnea '\n'
comillas(") '\"'
comilla simple(') '\''
signo interrogacin '\?'
backslash (\) '\\'
nulo '\0'
!.*., Con"tante" de cadena de caractere"
Una constante de cadena de caracteres consta de cualquier nmero de caracteres
consecutivos (o ninguno) encerrados entre comillas (").
14
El carcter nulo no puede aparecer en medio de una constante de cadena de
caracteres puesto que se usa para indicar fin de cadena. El carcter de fin de
cadena '\0' se coloca de forma automtica en las cadenas literales; as en la
cadena "abc" hay 4 caracteres: a, b, c y '\0'.
!.*.- Con"tante" "i2$%ica"
Una constante simblica es un nombre que sustituye una secuencia de caracteres.
Los caracteres pueden representar una constante numrica, una constante de
carcter o una constante de cadena. Por tanto, una constante simblica permite
que aparezca un nombre en lugar de una constante numrica, una constante de
carcter o una constante de cadena. Cuando se compila un programa, cada
aparicin de una constante simblica es reemplazada por su correspondiente
secuencia de caracteres.
Las constantes simblicas se suelen definir al comienza del programa. Las
constantes simblicas pueden entonces aparecer despus en el programa en
lugar de la constante numrica, la constante de carcter o la constante de cadena
que represente la constante simblica.
Se define una constante simblica escribiendo:
#define nombre texto
en donde nombre representa un nombre simblico, que se suele escribir en letras
maysculas, y texto representa la secuencia de caracteres asociadas al nombre
simblico. Advirtase que texto no termina con un punto y coma, ya que la
definicin de una constante simblica no es una verdadera sentencia de C. Es
ms, si texto terminase con punto y coma se tratara como si fuese parte de la
constante numrica, la constante de carcter o la constante de cadena que se
sustituye por el nombre simblico.
E/e2&%o: Un programa en C contiene las siguientes definiciones de constantes
simblicas:
#define NTERES 0.23
#define P 3.141593
#define CERTO 1
#define FALSO 0
#define AMGA "Martha
Ntese que los nombres simblicos estn escritos en maysculas, para
distinguirlos de los identificadores ordinarios de C.
15
Advirtase tambin que las definiciones no terminan en punto y coma.
Supngase que el programa contiene la sentencia:
area = P* radio *radio;
Durante el proceso de compilacin, cada aparicin de una constante simblica
ser remplazada por su correspondiente texto. Por tanto, la sentencia anterior se
transformar en:
area = 3.141593 * radio * radio;
Las constantes simblicas no son necesarias para escribir programas en C. Sin
embargo, se recomienda su utilizacin, ya que contribuye al desarrollo de
programas claros y ordenados. Por ejemplo, las constantes simblicas se
identifican de forma ms rpidas que la informacin que representan y los
nombres simblicos suelen sugerir el significado de sus datos asociados. Adems
es mucho ms fcil cambiar el valor de un nica constante simblica que cambiar
toda aparicin de alguna constante numrica que pueda aparecer en varios
lugares del programa.
!., O&eradore"
Hemos visto que las constantes, variables, elementos de array y referencias a
funciones se pueden unir con varios operadores para formar expresiones.
Tambin hemos mencionado que C posee un gran nmero de operadores que se
pueden agrupar en diferentes categoras.
Los datos sobre los que actan los operadores se denominan operandos. Algunos
operadores requieren dos operandos, mientras que otros actan slo sobre un
operando. La mayora de los operadores permiten que los operandos puedan ser
expresiones.
!.,.1 O&eradore" arit27tico"
Existen cinco operadores aritmticos en C:
Operador Propsito
+ adicin
- sustraccin
* multiplicacin
/ divisin
% resto de divisin entera (mdulo)
16
El operador % es a veces denominado operador mdulo.
No hay operador de exponenciacin en C. Sin embargo, hay una funcin de
biblioteca (pow) que realiza la exponenciacin.
Los operadores de C se agrupan jerrquicamente de acuerdo con su precedencia
(su orden de evaluacin).
Las operaciones con mayor precedencia se realizan antes que las operaciones
que tienen menor precedencia. Sin embargo, se puede alterar el orden natural de
evaluacin mediante el uso de parntesis.
Entre los operadores aritmticos *, / y % se encuentran dentro de un mismo grupo
de precedencia y + y - se encuentran en otro. El primer grupo tiene mayor
precedencia que el segundo. Por tanto, las operaciones de multiplicacin, divisin
y resta se realizan antes que las adiciones y sustracciones.
Otra cosa importante a considerar es el orden en que se realizan operaciones
consecutivas del mismo grupo de precedencia. Dentro de cada uno de los grupos
de precedencia descritos anteriormente la asociatividad es de izquierda a derecha.
En otras palabras, operaciones consecutivas de adicin y sustraccin se realizan
de izquierda a derecha, as como operaciones consecutivas de multiplicacin,
divisin y resta.
!.,.! O&eradore" re%aciona%e" ( %gico"
En C existen cuatro operadores relacionales:
O&erador +igni)icado
< menor que
<= menor o igual que
> mayor que
>= mayor o igual que
Estos operadores se encuentran dentro del mismo grupo de precedencia, que es
menor que la de los operadores monarios y aritmticos. La asociatividad de estos
operadores es de izquierda a derecha.
Muy asociados a los operadores relacionales, existen dos operadores de igualdad:
O&erador +igni)icado
== igual que
!= no igual que
17
Los operadores de igualdad se encuentran en otro grupo de precedencia, por
debajo de los operadores relacionales. La asociatividad de estos operadores es
tambin de izquierda a derecha.
Estos seis operadores se utilizan para formar expresiones lgicas que representan
condiciones que pueden ser ciertas o falsas. La expresin resultante ser de tipo
entero, ya que cierto es representado por el valor entero 1 y falso por el valor 0.
E/e2&%o:
Supongamos que i, j y k son variables enteras con valores asignados 1, 2 y 3
respectivamente. Se muestran a continuacin varis expresiones lgicas en las que
aparecen estas variables.
E'&re"ione" Inter&retacin #a%or
i < j cierto 1
(1+j)>=k cierto 1
(j+k) > (i+5) falso 0
(k = 3) falso 0
j==2 cierto 1
Adems de los operadores relacionales y de igualdad, C posee dos operadores
lgicos (denominados tambin conectivas lgicas):
O&erador +igni)icado
&& Y
O
Estos operadores se denominan y lgica y o lgica respectivamente.
Los operadores lgicos actan sobre operandos que son a su vez expresiones
lgicas. Permiten combinar expresiones lgicas, formando otras condiciones
lgicas ms complicadas que pueden ser ciertas o falsas. El resultado de una
operacin y lgica ser cierto slo si los dos operandos son ciertos, mientras que
el resultado de una operacin o lgica ser cierto si alguno de los operadores es
cierto o ambos a la vez. En otras palabras, el resultado de una operacin o lgica
ser falso slo si los dos operandos son falsos.
E/e2&%o: supongamos que i es una variable entera cuyo valor es 7, f una variable
de coma flotante cuyo valor es 5.5 y c una variable de carcter que representa el
carcter "w. Se muestran a continuacin varias expresiones lgicas compuestas
en las que aparecen estas variables.
E'&re"in Inter&retacin #a%or
(i>=6) && (c==`w`) cierto 1
(i>=b) (c==119) cierto 1
(f<11) && (i>100) falso 0
18
(c=`p`) ((i+f) <= 10) cierto 1
Tambin incluye C el operador monario !, que niega el valor de una expresin
lgica, es decir, hace que una expresin que era originalmente cierta se haga falsa
y viceversa. Este operador se denomina operador de negacin lgica (o no lgico).
Ejemplo: Supongamos que i es una variable entera con valor 7 y f una variable de
coma flotante con valor 5.5. A continuacin se muestran varias expresiones
lgicas en las que aparecen estas variables y el operador de negacin lgica.
E'&re"in Inter&retacin #a%or
f>5 cierto 1
! (f>5) falso 0
i <=3 falso 0
! (i<=3) cierto 1
i > (f+1) cierto 1
! (i > (f+1)) falso 0
!.,.* O&eradore" de incre2ento ( decre2ento
C incluye una clase de operadores que actan sobre un solo operando para
producir un nuevo valor. Estos operadores se denominan operadores monarios.
Los operadores monarios suelen preceder a su nico operando, aunque algunos
operadores monarios se escriben detrs de su operando.
Es probable que el operador monario de uso ms frecuente sea el menos monario,
se utiliza cuando un signo menos predice a una constante numrica, a una
variable o a una expresin. En C, todas las constantes numricas son positivas.
Por tanto, un nmero negativo es en realidad una expresin, que consiste en el
operador monario menos, seguido de la constante numrica positiva.
La operacin menos monaria es distinta al operador aritmtico que representa la
sustraccin (-). El operador sustraccin requiere dos operandos.
E/e2&%o:
-743 -0.2 -raz1
-(x+y) -5E-8 -3*(x+y)
En cada caso, el signo menos es seguido por un operando numrico que puede
ser una constante entera, una constante de coma flotante, una variable numrica o
una expresin aritmtica.
Otros dos operadores monarios de uso frecuente son el operador incremento 8 8,
y el operador decremento 9 9.
19
El operador incremento hace que su operando se incremente en uno,
mientras que el operador decremento hace, que su operando se
decremente en uno.
El operando utilizado con cada uno de estos operadores debe ser una
variable simple.
E/e2&%o: Supongamos que i es una variable entera que tiene asignado el valor 5.
La expresin ++i, que es equivalente a escribir i = i+1, hace que el valor de i sea 6.
Anlogamente, la expresin i, que es equivalente a i = i-1, hace que el valor
(partiendo del original) de i pase a ser 4.
!.,.,O&eradore" ( e'&re"ione" de a"ignacin
Definimos asignacin como la copia del resultado de una expresin sobre otra,
esto implica que dicho resultado debe tener LUGAR (es decir poseer una posicin
de memoria ) para alojar dicho valor .
Es por lo tanto vlido escribir
a = 17 ;
pero no es aceptado , en cambio
17 = a ; /* incorrecto */
ya que la constante numrica 17 no posee una ubicacin de memoria donde alojar
al valor de a .
Aunque parezca un poco extrao al principio las asignaciones, al igual que las
otras operaciones, dan un resultado que puede asignarse a su vez a otra
expresin.
De la misma forma que (a + b) es evaluada y su resultado puedo copiarlo en otra
variable : c = (a + b) ; una asignacin (a = b) da como resultado el valor de b , por
lo que es lcito escribir
c = ( a = b ) ;
Debido a que las asignaciones se evalan de derecha a izquierda, los parntesis
son superfluos, y podr escribirse entonces:
c = a = b = 17 ;
con lo que las tres variables resultarn iguales al valor de la constante .
El hecho de que estas operaciones se realicen de derecha a izquierda tambin
permite realizar instrucciones del tipo:
20
a = a + 17 ;
significando esto que al valor que tena anteriormente a , se le suma la constante y
LUEGO se copia el resultado en la variable.

Como este ltimo tipo de operaciones es por dems comn, existe en C un
pseudocdigo , con el fn de abreviarlas .
a += b ; /* equivale : a = a + b */
a -= b ; /* equivale : a = a - b */
a *= b ; /* equivale : a = a * b */
a /= b ; /* equivale : a = a / b */
a %= b ; /* equivale : a = a % b */
Ntese que el pseudooperador debe escribirse con los dos smbolos seguidos ,
por ejemplo += , y no ser aceptado +(espacio) = .
Re"u2en
Asignacin Operador Qu es (o qu hace)
=
*=
/=
%=
=
!=
"s#$%ac#&% s#'p(e
"s#$%ar produc)o
"s#$%ar coc#e%)e
"s#$%ar '&du(o
"s#$%ar su'a
"s#$%ar d#*ere%c#a
!.,.- Con0er"ione" de ti&o
Cuando escribimos una expresin aritmtica a+b, en la cual hay variables o
valores de distintos tipos, el compilador realiza determinadas conversiones antes
de que evale la expresin. Estas conversiones pueden ser para 'aumentar' o
'disminuir' la precisin del tipo al que se convierten los elementos de la expresin.
Un ejemplo claro, es la comparacin de una variable de tipo int con una variable
de tipo double. En este caso, la de tipo int es convertida a double para poder
realizar la comparacin.
Los tipos pequeos son convertidos de la forma siguiente: un tipo char se
convierte a int, con el modificador signed si los caracteres son con signo, o
unsigned si los caracteres son sin signo.
Un unsigned char es convertido a int con los bits ms altos puestos a cero.
Un signed char es convertido a int con los bits ms altos puestos a uno o cero,
dependiendo del valor de la variable.
21
Para los tipos de mayor tamao:
Si un operando es de tipo double, el otro es convertido a double.
Si un operando es de tipo float, el otro es convertido a float.
Si un operando es de tipo unsigned long, el otro es convertido a unsigned
long.
Si un operando es de tipo long, el otro es convertido a long.
Si un operando es de tipo unsigned, el otro es convertido a unsigned.
Si no, los operandos son de tipo int.
Una variable o expresin de un tipo se puede convertir explcitamente a otro tipo,
anteponindole el tipo entre parntesis.
!.,.: Precedencia ( orden de e0a%uacin
Una expresin est compuesta por operadores, variables y constantes. Para
simplificar, podemos pensar que la forma en la que C evala esta expresin es
dividiendo el todo en subexpresiones. Las reglas que definen que subexpresin
evaluar primero, se denominan reglas de precedencia. Aunque siempre podemos
alterar dichas reglas mediante la utilizacin de parntesis. En la siguiente tabla
detallamos la precedencia entre los operadores de C.
+a,or precede%c#a
( ) - . ! /
0 * 1 s#2eo* (operadores u%ar#os)
* / %
!


= = 0=
11

34
= = != *= /= %=
+e%or precede%c#a
22
!.- E'&re"ione"
Una expresin representa una unidad de datos simple, tal como un nmero o un
carcter. La expresin puede consistir en una entidad simple, con una constante,
una variable, un elemento de un array o una referencia a una funcin. Tambin
puede consistir en alguna combinacin de tales identidades interconectadas por
uno o ms operadores. El uso de expresiones involucrando operadores es
especialmente frecuente en C, como en muchos otros lenguajes de programacin.
Las expresiones tambin pueden representar condiciones lgicas que son
ciertas o falsas. En C las condiciones cierto y falso se representan por los
valores enteros 1 y 0, respectivamente. Por tanto, las expresiones lgicas
representan en realidad cantidades numricas.
E/e2&%o de expresiones sencillas:
a+b
x=y
c=a+b
x<=y
++i
En la primera expresin aparece el operador suma (+). La expresin representa la
suma de los valores asignados a las variables a y b.
En la segunda expresin aparece el operador asignacin (=). En este caso la
expresin hace que el valor que contenga y se le asigne a x.
La tercera expresin combina las caractersticas de las dos primeras expresiones.
En este caso se le asigna a la variable c el valor de la expresin a+b.
La cuarta expresin tendr el valor 1 (cierto) si el valor de x es menor o igual al de
y. De otra forma la expresin tendr el valor 0 (falso). En esta expresin, <= es un
operador relacional que compara los valores de las variables x e y.
La quinta expresin es una comprobacin de igualdad (comprese con la segunda
expresin, que es una expresin de asignacin). Por consiguiente, la expresin
tendr el valor 1 (cierto) si el valor de x es igual al valor de y. De otra forma, la
expresin tendr el valor 0 (falso).
23
La ltima expresin hace que el valor de la variable i se incremente en 1. por
tanto, la expresin es equivalente a i=i+1. El operador ++, que indica incremento
en 1, es un operador monario porque slo tiene un operador (en este caso, la
variable i).
!.: +entencia"
Una sentencia hace que la computadora lleve a cabo alguna accin. Hay tres tipos
diferentes de sentencias en C: sentencias de expresin, sentencias compuestas y
sentencias de control.
Una "entencia de e'&re"in consiste en una expresin seguida de un punto y
coma (;). La ejecucin de la sentencia hace que se evale la expresin.

Ejemplos de sentencias de expresin:
a=3;
c=a+b;
++i;
printf("Area=%f, area);
;
Las dos primeras sentencias de expresin son sentencias de tipo asignacin.
Cada una hace que el valor de la expresin a la derecha del signo igual le sea
asignado a la variable de la izquierda. La tercera sentencia de expresin es una
sentencia de tipo incremento, que hace que el valor de i sea incrementado en 1.
La cuarta sentencia de expresin hace que la funcin printf sea evaluada. Esta es
una funcin de biblioteca de C estndar que visualiza informacin. En este caso se
visualizar el mensaje Area=, segundo del valor actual de la variable area. As, si
area tiene el valor 100, la sentencia generara el mensaje:
Area = 100.000000
La ltima sentencia de expresin no hace nada, ya que consta slo de un punto y
coma. Es un sencillo mecanismo de conseguir una sentencia de expresin vaca
en lugares en donde se requiera este tipo de sentencia. Consecuentemente se
denomina sentencia nula.
Una "entencia co2&ue"ta est formada por varias sentencias individuales
encerradas con un par de llaves ({y}). Las sentencias individuales pueden ser a su
vez sentencias de expresin, sentencias compuestas o sentencias de control.
Por tanto, la sentencia compuesta hace posible incluir sentencias dentro de otras
sentencias. A diferencia de una sentencia de expresin, una sentencia compuesta
no termina con un punto y coma.
Ejemplo de sentencia compuesta:
{
pi = 3.141593;
24
circunferencia = 2*pi*radio;
area = pi*radio*radio;
}
Esta sentencia, compuesta en particular, consta de tres sentencias de expresin
de tipo asignacin, aunque es considerada como una nica entidad dentro del
programa en que aparece. Ntese que la sentencia compuesta no termina con un
punto y coma despus de la llave.
Las "entencia" de contro% se utilizan para conseguir ciertas acciones especiales
en los programas, tales como comprobaciones lgicas, bucles y ramificaciones.
Muchas sentencias de control requieren que otras sentencias se encuentren
incluidas en ellas.
Ejemplo: la siguiente sentencia de control crea un bucle condicional en el que se
ejecutan varias acciones repetidamente, hasta que se satisface una condicin en
particular.
while (cont<=n) {
printf("x=);
scanf("%f, &x);
++cont;
}
Esta sentencia contiene una sentencia compuesta, que a su vez contiene cuatro
sentencias de expresin. La sentencia compuesta se seguir ejecutando hasta
que el valor de cont exceda el valor de n. Ntese que cont se incrementa en 1 en
cada pasada por el bucle.
!.; .uncione" de $i$%ioteca"
Las funciones de biblioteca son funciones realizadas anteriormente y que se
encuentran disponibles para que el usuario pueda utilizar segn sus propias
necesidades.

En este apartado el estudiante deber realizar una investigacin en la que deber
mencionar cada uno de los archivos de biblioteca y las funciones que estn
incluidas en l.
25
Unidad *: Entrada ( +a%ida de dato"
O<JE1I#O+
a) Controlar el flujo de informacin a travs de las funciones de printf y scanf
b) Utilizar correctamente las funciones gets, puts, getchar, putchar
CON1ENIDO+
3.1 ntroduccin
3.2 Funcin pritnf
3.3 Funcin scanf
3.4 Funciones gets y puts
3.5 Funciones getchar y putchar
1. Introduccin
En C no existe ninguna palabra clave para realizar la entrada y salida de datos
(E/S). Se realizan a travs de funciones de biblioteca
(concretamente, la biblioteca stdio.h)
*.! .uncin &ritn)
Se puede escribir datos en el dispositivo de salida estndar utilizando la funcin de
biblioteca printf. Se puede utilizar esta funcin para escribir cualquier combinacin
de valores numricos, caracteres sueltos o cadena de caracteres. La funcin
printf se ocupa de transportar datos de la memoria de la computadora al
dispositivo de salida estndar.
En trminos generales la funcin printf se escribe:
printf(cadena de control, arg1, arg2, ... , argn)
En donde la cadena de control hace referencia a una cadena de caracteres que
contiene informacin sobre el formato de la salida y los argumentos representan
los datos de salida. Los argumentos pueden ser constantes, variables simples,
nombres de arrays, o expresiones ms complicadas. En contraste con la funcin
scanf, los argumentos en la funcin printf no representan direcciones de memoria
y por lo tanto no son precedidos por anspersand.
La cadena de control est compuesta por grupos de caracteres, con un grupo de
caracteres por cada dato de salida. Cada grupo de caracteres debe comenzar por
un signo de porcentaje (%). En su forma ms sencilla, un grupo de caracteres
consistir en el signo de porcentaje seguido de un carcter de conversin que
indica el tipo de dato correspondiente.
26
Caracteres de conversin de los datos de salida de uso comn
Carcter de
Conversin
Significado
c El dato es visualizado como un carcter
d El dato es visualizado como un entero decimal con signo
e El dato es visualizado como un valor en coma flotante con
exponente
f El dato es visualizado como un valor en coma flotante sin
exponente
i El dato es visualizado como un entero con signo
o El dato es visualizado como un entero octal
s El dato es visualizado como una cadena de caracteres
u El dato es visualizado como un entero decimal sin signo
x El dato es visualizado como un entero hexadecimal.
E/e2&%o:
#include <stdio.h>
main( ) {
char letras[20];
int entero;
float costo;
...
printf("%s %d %f, letras, entero, costo);
...
}
La funcin printf interpreta la conversin de tipo s de forma diferente a como lo
hace la funcin scanf. En la funcin printf se utiliza la conversin tipo s para
visualizar una cadena de caracteres que acaba con el carcter nulo (\0). Se
pueden incluir caracteres espaciados en la cadena de caracteres.
E/e2&%o:
#include <stdio.h>
main( )
{
char linea[80];
....
scanf("%[^\n],linea);
printf("%s,linea);
Tambin es posible especificar el mximo nmero de cifras decimales para un
valor de coma flotante, o el mximo nmero de caracteres para una cadena de
27
caracteres, esta especificacin se denomina precisin. La precisin es un entero
sin signo que siempre es precedido por un punto decimal.
Un nmero de coma flotante se redondear si se debe recortar para ajustarse a la
precisin especificada.
E/e2&%o:
#include <stdio.h>
main( )
{
float x=123.456;
...
printf("%7f %7.3f %7.1f \n\n, x, x, x);
....
}
El programa generar la sig. Salida:
123.456000 123.456 123.5
No es necesario que la especificacin de la precisin vaya acompaada de la
longitud de campo mnima. Es posible especificar la precisin sin la longitud de
campo mnima, aunque la precisin debe de seguir apareciendo precedida de un
punto decimal.
*.* .uncin "can)
Se puede introducir cualquier combinacin de valores numricos, de carcter y de
cadena de caracteres. La funcin devuelve el nmero de datos que se han
conseguido introducir correctamente.
+inta'i": "can)=cadena de contro%,arg1,arg!,...argn>?
La cadena de control hace referencia a una cadena de caracteres que contiene
informacin sobre el formato de los datos y los argumentos representan datos que
son punteros que indican las direcciones de memoria en donde se encuentran los
datos.
En la cadena de control se incluyen grupos individuales de caracteres por cada
dato de entrada, cada uno de estos grupos deben empezar con % seguido del
carcter de conversin que indica el tipo de dato correspondiente.
Caractere" de con0er"in.
28
Caracter de
Conversin
Significado
C El dato es un carcter
D El dato es un entero decimal
E El dato es un valor en coma flotante
F El dato es un valor en coma flotante
G El dato es un valor en coma flotante
H El dato es un entero corto
El dato es un entero decimal, octal o hexadecimal
O El dato es un entero octal
S El dato es una cadena de caracteres seguida de un
carcter de espaciado(se aade automticamente el
carcter nulo \0 al final).
U El dato es un entero decimal sin signo
X El dato es un entero hexadecimal
[...] El dato es una cadena de caracteres que puede incluir
carcter de espaciado.
Los argumentos pueden ser variables o arreglos y sus tipos deben coincidir con
los indicadores en la cadena de control cada nombre de variable debe ser
precedido por un ampersand (&) excepto los nombres de arreglo.
E/e2&%o: La siguiente es una aplicacin tpica de la funcin scanf.
#include <stdio.h>
void main( )
{
char letras [20];
int suma;
float costo;
...........
scanf("%s %d %f, letras, &suma, &costo);
...........
}
La conversin de caracteres de tipo " se aplica a una cadena de caracteres que
finaliza con un carcter de espacio de tal manera si se desea leer una cadena que
incluya espacios en blanco debe usar la funcin scanf utilizando una secuencia de
caracteres [...]
E/e2&%o:
char linea[80];
............
scanf("%[ A,B,C,D,E,...Z],linea);
29
Otra forma de hacer esto es preceder los caracteres dentro de los corchetes por
un circunflejo esto hace que los caracteres dentro de los corchetes se interpreten
en forma opuestos.
E/e2&%o:
char linea[80];
...
scanf("%[^\n], linea);
La mayora de las versiones de C permite que ciertos caracteres de conversin de
la cadena de control sean precedidos por un prefijo de una sola letra, que indica la
longitud del argumento correspondiente. Por ejemplo, una l (l minscula) se utiliza
para indicar un argumento entero largo, tanto con signo como sin signo.
Anlogamente se utiliza una h para indicar un entero corto tanto con signo como
sin signo.
E/e2&%o:
short ix, iy;
long lx, ly;
double dx, dy;
...
scanf("%hd, %ld, %lf, &ix, &lx, &dx);
E/e2&%o"
Ejercicio 1: EL PRIMER PROGRAMA
/* nombre del archivo primero.cpp
Este programa saluda desenfadadamente. */
#include <stdio.h>
void main(void)
{
printf("Hola! Qu tal ests, futuro programador?\n");
}
Nota4 5a pr#'era (6%ea de es)e pro$ra'a es u% co'e%)ar#o7 , es #$%orado por e(
co'p#(ador/ 5a d#rec)#8a #include per'#)e u)#(#2ar (a (#9rer6a stdio7 #%d#spe%sa9(e para
d#*ere%)es #%s)rucc#o%es de e%)rada/sa(#da de( (e%$ua:e ;/ <( arch#8o stdio.h co%)#e%e (as
dec(arac#o%es de (as *u%c#o%es de e%)rada/sa(#da7 as6 co'o de*#%#c#o%es de co%s)a%)es
s#'9&(#cas , a($u%as o)ras de*#%#c#o%es de u)#(#dad/ 5a pa(a9ra void es opc#o%a(= #%d#ca que
(a *u%c#&% main() %o )#e%e 8a(or de re)or%o %# ar$u'e%)os/
Ejercicio 2: UNA CONVERSACIN EN C
30
/* nombre del archivo segundo.cpp
Este programa saluda ms personalmente */
#include <stdio.h>
void main(void)
{
char nombre[30];
printf("Hola! Cmo te llamas?\n");
scanf("%s", nombre);
printf("Qu tal ests, %s?\n", nombre);
}
Nota: La sentencia char nombre[30], declara una variable llamada nombre que
es una cadena de 30 caracteres (tipo char). Estos caracteres se numeran del 0 al
29, y deben incluir la marca de fin de cadena @AB@. Con la funcin scanf(, se lee lo
que ser el contenido dicha cadena por medio del formato C", que es propio de
las cadenas de caracteres. Como la lectura se detiene al encontrar un blanco, un
carcter nueva lnea o un tabulador, por medio de este programa no se puede leer
una frase sino slo una palabra.
E/ercicio *: PREGUN1A+ INDI+CRE1A+.
En este programa vas a utilizar la funcin scanf() con distintos tipos de variables.
De paso podrs contestar a algunas preguntas indiscretas, pero de indudable
inters social. El siguiente programa debe ser almacenado en un fichero llamado
mascota.cpp.
Si tu mascota favorita es una boa, una ardilla o una gacela, tendrs que cambiar el
artculo "un" por "una", para respetar la concordancia.
// nombre del archivo mascota.cpp
#include <stdio.h>
void main(void)
{
int edad;
float sueldo;
char cachorro[30];
printf("Confiesa tu edad, sueldo y mascota favorita.\n");
scanf("%d %f",&edad, &sueldo);
scanf("%s", cachorro);
printf("%d %.0f pts. %s\n",edad, sueldo, cachorro);
printf("Un %s!!!!", cachorro);
printf("Cmo te puede gustar un %s?\n", cachorro);
}
Nota: En la funcin scanf(, se incluye el operador direccin (&) delante de las
variables escalares para pasar a la funcin las direcciones de dichas variables.
31
Recordemos que para leer cadenas de caracteres basta poner el nombre de la
cadena, que de por s ya es una direccin.
*., Autoe0a%uacin
1. Convierta en expresiones vlidas en C los siguientes enunciados y
expresiones matemticas:
a) 5(x+y)
b) a2 + b2
c) Seis veces la diferencia entre 25 y 3
d) La suma de a y b, dividido por c y todo ello dividido por d
2. Defina las siguientes constantes:
a) Constante CARRERA para que represente "ngeniera de Sistemas
b) Constante ARANCEL para que represente la cuota en crdobas que
Usted paga en la UENC
3. Dada la ecuacin y = ax
3
+15, Cul de los siguientes enunciados
corresponde a esta ecuacin?
a) y = a * x * x *x + 15
b) y = a * x * x *(x + 15)
c) y = a * (x * x *x) + 15
4. Suponga que a, b y c son variables enteras que tienen asignados los
valores de a=8, b=3 y c=7 y el '7' codificado como 55 en el conjunto de
caracteres ASC. Determine el valor de cada una de las siguientes
expresiones:
a) 2 * b + 3 * (a-c)
b) a % b
c) a + b +7
32
5. Escribir un programa que imprima una lnea de texto, donde cada palabra
aparecer en una lnea. Ejemplo:
Resultado:
esto
es
una
lnea
6. Elabore un programa que lea dos nmeros enteros, luego imprima la suma,
diferencia, producto y cociente de dichos nmeros.
7. Elabore un programa que lea el ao de nacimiento de una persona e
imprima la edad que tendr esa persona en el ao 2010.
33
?nidad O$ E%tructura% d# %#)#ccin
OBJETIVOS
a/ Hominar las estructuras de seleccin para la solucin de problemas
b/ Hiferenciar las sentencia .(..>*E# .EL1E y la sentencia 1_.>C*.
CONTENIDOS
O.3 .ntroduccin
O.; 1imples ,if/
O.< Hobles ,if&else/
O.O Compuestas ,1+itc%&case/
1.1 INTRODUCCIN
C proporciona tres tipos de estructuras de seleccin. La estructura de seleccin i3, ya sea ejecute ,elige/ una accin, si
una condicin es verdadera, o pasa por alto la accin, si la condicin es falsa. La estructura de seleccin i3.#)%# ejecuta
una accin, si la condicin es verdadera, o ejecuta una accin diferente, si la condicin es falsa. La estructura de
seleccin %8itc0 ejecuta una de entre muc%as acciones diferentes, dependiendo del valor de una expresin.
La estructura i3 se llama estructura de una sola seleccin, por!ue selecciona o ignora una accin. La estructura i3.#)%#
se conoce como estructura de doble seleccin, por!ue selecciona entre dos acciones distintas. La estructura %8itc0 se
conoce como una estructura de seleccin mltiple, por!ue selecciona entre muc%as acciones diferentes.
C proporciona tres tipos de estructuras de repeticin, es decir 80i)#, as) como do.80i)# y 3or.
C tiene slo siete estructuras de control$ de secuencia, tres tipos de seleccin y tres de repeticin. Cada programa de C
se forma al combinar tantos de cada tipo de estructura de control como sean apropiados
En lo !ue sigue de este cap)tulo, denominaremos 6L2]?E HE 1E#>E#C.01 al conjunto de sentencias individuales
inclu)das dentro un par de llaves. -or ejemplo $
A
sentencia 3 '
sentencia ; '
.............
sentencia n '
B
Este conjunto se comportar sintacticamente como una sentencia simple y la llave de cierre del blo!ue #2 debe ir
seguida de punto y coma.
?n ejemplo de blo!ue, es el cuerpo del programa principal de la funcin main,/ .
main,/
A
blo!ue de sentencias
B
En las proposiciones de control de flujo de programa, trabajaremos alternativamente con sentencias simples y blo!ues
de ellas.
1.* Si(&)#% 9i3:
?na estructura de seleccin se utiliza para elegir entre cursos alternativos de accin. -or ejemplo, suponga !ue en un
exmen 4= es la calificacin de aprobado. El enunciado en seudocdigo es$
34
1i calificacin del estudiante es mayor !ue o igual a 5=
.mprimir I0probL
Hetermina si la condicin Ila calificacin del estudiante es mayor !ue o igual a 4=L es verdadera o falsa. 1i la condicin
es verdadera, entonces se imprime I0probL. 1i la condicin resulta falsa, se ignora la impresin, y se ejecuta el
siguiente enunciado del seudocdigo en su orden. #ote !ue la segunda l)nea de esta estructura de seleccin est con
sangr)a. Esta sangr)a es opcional, pero es muy recomendada, ya !ue auxilia a enfatizar la estructura in%erente de los
programas estructurados.
El enunciado anterior en seudocdigo .f puede ser escrito en C como$
if ,calificacin GJ 4=/
printf,I0probSnL/'
1.- Do!)#% 9i3;#)%#:
La estructura de seleccin if ejecuta una accin indicada slo cuando la condicin es verdadera' de lo contrario la accin
es pasada por alto. La estructura de seleccin ifCelse permite !ue el programador especifi!ue !ue se ejecuten acciones
distintas cuando la condicin sea verdadera !ue cuando la condicin sea falsa. -or ejemplo, el enunciado en
seudocdigo$
if calificacin del estudiante es mayor !ue o igual a 4=
printf I0probL
else
printf I7eprobL
.mprime 0prob, si la calificacin del alumno es mayor !ue o igual a 4= e imprime 7eprob si la calificacin del alumno
es menor de 4=. En cual!uiera de los casos, despus de %aber terminado la impresin, se ejecutar el siguiente
enunciado del seudocdigo. El cuerpo del Else tambin !ueda con sangr)a.
El seudocdigo anterior correspondiente a la estructura ifCelse puede ser escrito en C como$
if ,calificacin GJ 4=/
printf,I0probSnL/'
else
printf,I7eprobSnL/'
C tiene el operador condicional ,K$/ !ue est relacionado de cerca con la estructura i3.#)%#. El operador condicional es el
nico operador ternario de C &&utiliza tres operandos. Los operandos, junto con el operador condicional, conforman una
expresin condicional. El primer operando es una condicin, el segundo operando es el valor de toda la expresin
condicional si la condicin es verdadera, y el tercer operando es el valor de toda la expresin condicional si la condicin
es falsa. -or ejemplo, el enunciado printf$
printf,IMsSnL, calificacin GJ 4= K I0probL $ I7eprobL/'
Los valores en una expresin condicional tambin pueden ser acciones a ejecutar. -or ejemplo, la expresin
condicional$
Calificacin GJ 4= K printf,I0probSnL/ $ printf,I7eprobSn/'
Los operadores condicionales pueden ser utilizados en algunas situaciones donde los enunciados i3.#)%# no pueden ser
usados.
35
Las estructuras ifCelse anidadas prueban para muc%os casos, colocando estructuras ifCelse dentro de estructuras ifCelse.
-or ejemplo el fragmento siguiente, imprimir 0 para calificaciones mayores !ue o iguales a :=, 6 para calificaciones
mayores !ue o iguales a 9=, C para calificaciones mayores !ue o iguales a 5=, H para calificaciones mayores !ue o
iguales a 4=, y ( para todas las dems calificaciones$
if ,calificacin GJ :=/
printf,I0SnL/'
else
if ,calificacin GJ 9=/
printf,I6SnL/'
else
if ,calificacin GJ 5=/
printf,ICSnL/'
else
if ,calificacin GJ 4=/
printf,IHSnL/'
else
printf,I(SnL/'
\uc%os programadores de C prefieren escribir la estructura if anterior, como sigue$
if ,calificacin GJ :=/
printf,I0SnL/'
else if ,calificacin GJ 9=/
printf,I6SnL/'
else if ,calificacin GJ 5=/
printf,ICSnL/'
else if ,calificacin GJ 4=/
printf,IHSnL/'
else
printf,I(SnL/'
0mbas formas resultan e!uivalentes.
La estructura de seleccin if espera un enunciado dentro de su cuerpo. -ara incluir varios enunciados en el cuerpo de
un if, encierre el conjunto de enunciados entre llaves , A y B /. ?n conjunto de enunciados contenidos dentro de un par de
llaves se conoce como un enunciado compuesto.
Ejemplo$ se incluye un enunciado compuesto en la parte else de una estructura ifCelse.
if ,calificacin GJ 4=/
printf,I0probSnL/'
else A
printf,I7eprobSnL/'
printf,IHebe tomar este curso de nuevoL/'
B
E"#(&)o
Einclude Fstdio.%G
void main,/
A
int a,b,c'
printf,"El siguiente programa, le solicita tres nmeros enteros"/'
printf,"Sn-ara luego imprimir el mayor de los tres"/'
36
printf,"SnSn.ntroduzca tres enterosSn"/'
scanf,"MdMdMd",Na,Nb,Nc/'
if ,aGb/
if ,aGc/
printf,"SnSnEl mayor de Md, Md y Md es$ Md",a,b,c,a /'
else
printf,"SnSnEl mayor de Md, Md y Md es$ Md",a,b,c,c /'
else
if ,b Gc /
printf,"SnSnEl mayor de Md, Md y Md es$ Md",a,b,c,b /'
else
printf,"SnSnEl mayor de Md, Md y Md es$ Md",a,b,c,c /'
printf,"SnSnSnStSt RRRRR (.# HEL -72`70\0 RRRRR"/'
B
1.1 Co(&u#%ta% 9S8itc0;ca%#:
0nteriormente analizamos la estructura de una seleccin if, y la estructura de doble seleccin if/else. En forma
ocasional, un algoritmo contendr una serie de decisiones, en las cuales una variable o expresin se probar por
separado contra cada uno de los valores constantes enteros !ue puede asumir, y se tomarn diferentes acciones. -ara
esta forma de toma de decisiones se proporciona una estructura de seleccin mltiple switch C.
La estructura switch est formada de una serie de eti!uetas case, y de un caso opcional default.
leer expresin de control
s+itc% expresin de controlA
case 3$ conjunto de expresiones'
brea['
case ;$ conjunto de expresiones'
brea['
case <$ conjunto de expresiones'
brea['
...
case n$ conjunto de expresiones'
brea['
default$ L\ensaje de errorL'
El enunciado break causa !ue el control de programa contine con el primer enunciado !ue sigue despus de la
estructura switch. 1e utiliza el enunciado break, por!ue de lo contrario los cases en un enunciado switch se ejecutar)an
juntos. 1i no existe coincidencia, el caso default es ejecutado y se imprime un mensaje de error.
Cada case puede tener una o ms acciones. La estructura switch es diferente de todas las dems estructuras, en el
sentido de !ue no se re!uieren llaves alrededor de varias acciones en un case de un switch.
El 1_.>C* es una forma sencilla de evitar largos , tediosos y confusos anidamientos de EL1E&.( .
E"#(&)o:
37
-rograma !ue permite seleccionar entre calcular el rea de un c)rculo, de un tringulo y de un rectngulo usando la
estructura de seleccin mltiple %8itc0.
Este es un ejemplo de un programa de men.
CD Ejemplo de programa usando la estructura s+itc% DC
Einclude Fstdio.%G
main, / A
float radio,area,b,%'
int opcion'
printf,"-72`70\0 HE \E#? E# C ]?E 7E0L.a0 b07.21 C0LC?L21SnSn"/'
printf," 3& 0rea del circuloSnSn"/'
printf," ;& 0rea del tringuloSnSn"/'
printf," <& 0rea del rectnguloSnSn"/'
printf,"Escriba la opcin deseada$"/'
scanf,"Md",Nopcion/'
s+itc%,opcion/A
case 3$ printf,"Escriba el valor del radio$"/'
scanf,"Mf",Nradio/'
areaJ<.3O3P:DradioDradio'
printf,"El rea del c)rculo es$ MfSn",area/'
brea['
case ;$ printf,"Escriba la base$"/'
scanf,"Mf",Nb/'
printf,"Escriba la altura$"/'
scanf,"Mf",N%/'
areaJ,bD%/C;'
printf,"El rea del tringulo es$ MfSn",area/'
brea['
case <$ printf,"Escriba la base$"/'
scanf,"Mf",Nb/'
printf,"Escriba la altura$"/'
scanf,"Mf",N%/'
areaJbD%'
printf,"El rea del tringulo es$ MfSn",area/'
brea['
default$printf,"Sn"/'
printf,"SnDDDD#mero .nvlidoDDDDSn"/'
B
printf,"Sn DDDDD (.# HEL -72`70\0 DDDDD"/'
return ='
B
1.4 Auto#$a)uacin
3. c]u errores de sintaxis tiene la siguiente sentenciaK
if xG ;P.=
y J x
else
y J z'
;. c]u valor se asigna a consumo en la sentencia if siguiente si velocidad es 3;=K
if ,velocidad G 9=/
38
consumo J 3=.=='
else
if ,velocidad G3==/
consumo J 3;.=='
else
if ,velocidad G 3;=/
consumo J 3P.=='
<. Explica las diferencias entre las sentencias de la columna de la iz!uierda y de la columna de la derec%a. -ara cada
una de ellas deducir el valor final de x si el valor inicial de x es =.
if ,x GJ = / if ,x GJ =/
xdd' xdd'
else if ,xGJ 3/' if ,xGJ 3/
xdJ ;' xdJ;'
O. Escribir un programa !ue lea tres enteros y emita un mensaje !ue indi!ue si estn o no en orden numrico.
39
Unidad 4: S#nt#ncia% d# contro)
OBJETIVOS
a/ Hominar las estructuras de control necesarias para escribir programas.
b/ -resentar las estructuras repetitivas (27, _*.LE..H2 y la sentencia H2 _*.LE.
c/ Hiferenciar entre las estructuras repetitivas _*.LE..H2 y la estructura H2.._*.LE.
CONTENIDOS
P.3 .ntroduccin
P.; 1entencia C)clicas +%ile
P.< , 1entencia C)clicas do
P.O 1entencia C)clicas for
P.P 1entencias C)clicas anidadas
P.4 1entencias brea[ y continue.
4.1 Introduccin
1entencias de iteracin tambin denominadas bucles. -ermiten realizar un conjunto de instrucciones %asta !ue se
alcance una cierta condicin ,!ue puede estar predefinida como en el bucle for' o no %aber final predeterminado, como
en los bucles +%ile y do&+%ile/.
La condicin es una expresin relacional !ue determina cuando finaliza el bucle. El incremento define como cambia la
variable de control cada vez !ue se repite el bucle.
4.* S#nt#ncia C6c)ica% 80i)#
?na #%tructura d# r#&#ticin le permite al programador especificar !ue se repita una accin, en tanto cierta condicin
se mantenga verdadera. El enunciado en seudocdigo
,+%ile/ En tanto !ueden elementos en mi lista de compras
0d!uirir elemento siguiente y tac%arlo de la lista
Hescribe la repeticin !ue ocurre durante una salida de compras. La condicin IEn tanto !ueden elementos en mi lista
de comprasL puede ser verdadera o falsa. 1i es verdadera, entonces la accin, I0d!uirir elemento siguiente y tac%arlo
de la listaL se ejecutar. Esta accin se ejecutar en forma repetida, en tanto la condicin sea verdadera.
Sinta<i%
+%ile , condicin /
sentencia
El enunciado o enunciados contenidos en la estructura de repeticin +%ile constituyen el cuerpo del +%ile. El cuerpo de
la estructura +%ile puede ser un enunciado sencillo o un enunciado compuesto.
Eventualmente, la condicin se %ar falsa ,cuando se %aya ad!uirido el ltimo elemento de la lista de compras y se %aya
tac%ado de la misma/. Llegado a este punto, la repeticin se termina, y se ejecutar el enunciado en seudocdigo !ue
sigue de inmediato despus de la estructura de repeticin.
Como ejemplo de un +%ile real, considere un segmento de programa dise8ado para encontrar la primera potencia de ;
superior a 3===. 1uponga la variable de entero product inicializada a ;. Cuando la estructura de repeticin +%ile
siguiente termine de ejecutarse, product contendr la respuesta deseada$
40
product J ;'
+%ile ,product FJ 3===/
product J ; D product'
E"#(&)o 1 $ -rograma permite imprimir los nmeros enteros del 3 al 3=.
Einclude Fstdio.%G
void main, / CDbisualiza los nmeros del 3 al 3=DC
A
int numJ3'

+%ile ,numFJ3=/
printf,IMdSnL,numdd/'
B
E"#(&)o * $
main,/
A
int xJ3'
+%ile , x F 3== /
A
printf,IL)nea nmero MdSnL,x/'
xdd'
B
B
E"#(&)o -: usando el operador de decremento$
main,/
A
int xJ3='
+%ile , &&x /
A
printf,Iuna l)neaSnL/'
B
B
En cada iteracin se decrementa la variable < y se comprueba el valor devuelto por ;;< . Cuando esta expresin devuelva
un cero, se abandonar el bucle. Esto ocurre despus de la iteracin en la !ue < vale uno.
4.- = S#nt#ncia C6c)ica% do
La forma general de la instruccin do & +%ile es$
do instruccin while (expresin)
La instruccin se ejecutar repetidamente, mientras !ue el valor de expresin sea cierto ,es decir, no cero/. #tese !ue
instruccin siempre se ejecutar al menos una vez, ya !ue el test de la condicin de repeticin no se realiza %asta el final
de la primera pasada por el bucle. La instruccin puede ser simple o compuesta, aun!ue en la mayor)a de las veces
ser compuesta. Hebe incluir algn elemento !ue altere el valor de expresin para !ue el bucle tenga un final.
-ara la mayor)a de las aplicaciones es ms natural comprobar la condicin al comienzo del bucle !ue al final. -or esta
razn, la instruccin do @ +%ile se utiliza con menor frecuencia !ue la instruccin +%ile.
41
EJEMPLO >1
Cantidades enteras consecutivas. -rograma para visualizar los nmeros =,3,;,...,:. ?tiliza la instruccin do @ +%ile.
Einclude Fstdio.%G
void main, / CDbisualizar los nmeros del = al :DC
A
int digitoJ='

do
printf,IMdSnL,digitodd/'
+%ile ,digitoFJ:/'
B
Le es asignado inicialmente a d)gito el valor =. El bucle do @ +%ile visualiza el valor actual de d)gito, incrementando su
valor en 3, y a continuacin comprueba si el valor actual de d)gito es mayor !ue :. 1i es as), el bucle finaliza' en otro
caso, continua el bucle, utilizando el nuevo valor de d)gito. #tese !ue el test se lleva a cabo al final de cada pasada por
el bucle. El efecto global es !ue el bucle se repite 3= veces, generndose 3= l)neas de salida.
EJEMPLO >*
Conversin de minsculas a maysculas.
-rograma !ue convierte un texto de minsculas a maysculas. Leeremos primero una l)nea de texto en minsculas
carcter a carcter, almacenaremos los caracteres en una formacin llamada letras y lo escribiremos a continuacin en
maysculas utilizando la funcin de biblioteca toupper. ?tilizaremos una instruccin do @ +%ile para leer la l)nea de texto
carcter a carcter y otra instruccin do @ +%ile para convertir los caracteres a maysculas y escribirlos.
CD Convertir una l)nea de texto de minsculas a maysculas DC
Einclude Fstdio.%G
Einclude Fctype.%G
Edefine E2L XSnX
void main, /
A
c%ar letrasV9=Y'
int aux,cont J &3'
CD Leer el texto en minsculas DC
do ddcont' +%ile ,,letrasVcontYJgetc%ar, //RJE2L/'
auxJcont'
CD Escribir el texto en maysculas DC
contJ='
do A
putc%ar,toupper,letrasVcontY//'
ddcont'
B +%ile ,contFaux/'
B
He nuevo vemos dos tipos diferentes de bucles, aun!ue ambos se escriban como bucles do @ +%ile en particular. El
nmero de pasadas por el primer bucle no es conocido a priori, pero el segundo bucle ejecuta un nmero conocido de
pasadas, determinado por el valor asignado a aux.
EJEMPLO >-
42
\edia de una lista de nmeros.
CDCalcular la media de n nmerosDC
Einclude Fstdio.%G
void main,/
A
int n,contJ3'
float x,media,sumaJ='
CD.nicializar y leer el valor de nDC
printf,IcCuntos nmeros$KL/'
scanf,IMdL,Nn/'
CDLeer los nmerosDC
do A
printf,IxJ I/'
scanf,IMfL,Nx/'
sumadJx'
ddcont'
B +%ile ,contFJn/'
CDCalcular la media y escribir la respuestaDC
mediaJsumaCn'
printf,ISn La media es MfSnL, media/'
B
4.1 S#nt#ncia C6c)ica% 3or
La instruccin 3or es la tercera y !uizs la ms frecuentemente usada de las instrucciones para crear bucles en C. Esta
instruccin incluye una expresin !ue especifica el valor inicial de un )ndice, otra expresin !ue determina cuando se
contina o no el bucle y una tercera expresin !ue permite !ue el )ndice se modifi!ue al final de cada pasada.
La forma general de la instruccin (27 es$
for (expresin 1; expresin 2; expresin 3) instruccin
En donde expresin 3, se utiliza para inicializar algn parmetro ,denominado )ndice/ !ue controla la repeticin del bucle,
expresin ;, representa una condicin !ue debe ser satisfec%a para !ue se contine la ejecucin del bucle y expresin <,
se utiliza para modificar el valor del parmetro inicialmente asignado por expresin 3. >)picamente, expresin 3 es una
expresin de asignacin, expresin ; una expresin lgica y expresin < una expresin monaria o una expresin de
asignacin.
Cuando se ejecuta la instruccin (27, se evala expresin ; y se comprueba antes de cada pasada por el bucle, y al
final de cada pasada se evala expresin <. -or tanto, la instruccin (27 es e!uivalente a$
expresin 3'
+%ile ,expresin ;/ A
instruccin
expresin <'
B
La ejecucin repetida del bucle continuar mientras el valor de expresin ; no sea cero, esto es, mientras la condicin
lgica representada por expresin ; sea cierta.
La instruccin for, lo mismo !ue las instrucciones +%ile y do @ +%ile, se pueden utilizar para realizar repeticiones donde
no se conozca a priori el nmero de pasadas por el bucle. 1in embargo, debido a los elementos incorporados en la
43
instruccin for, esta es particularmente adecuada para bucles donde se conozca a priori el nmero de pasadas. Como
regla prctica, los bucles +%ile se utilizan generalmente cuando no se conoce a priori el nmero de pasadas, y los bucles
for se utilizan generalmente cuando si se conoce a priori el nmero de pasadas.
EJEMPLO > 1
Cantidades enteras consecutivas.
ea %emos visto diferentes versiones de un programa en C !ue visualiza los nmero =,3,;,...,:. ?no en cada l)nea. *e
a!u) otro programa !ue %ace lo mismo. 0%ora, sin embargo, se utiliza la instruccin (27.
Einclude Fstdio.%G
void main, / CDbisualizar los nmeros del = al :DC
A
int digitoJ='

for ,digitoJ='digitoFJ:' dddigito/
printf,IMdSnL,digito/'
B
La primera l)nea de la instruccin for contiene tres expresiones, encerradas entre parntesis. La primera expresin
asigna un valor inicial = a la variable entera d)gito' la segunda expresin establece !ue el bucle se repetir mientras !ue
el valor actual de d)gito no sea mayor !ue : al comienzo de cada pasada' y la tercera expresin incrementa en 3 el valor
de d)gito en cada pasada por el bucle. La funcin printf incluida en el bucle for produce la salida deseada, como se vio
anteriormente.
Hesde el punto de vista sintctico no es necesario !ue se encuentren presentes las tres expresiones en la instruccin for,
aun!ue deben aparecer los puntos y comas. 1in embargo, se deben entender claramente las consecuencias de esta
omisin. 1e pueden omitir las expresiones primera y tercera si se inicializa yCo altera el )ndice de alguna otra forma. 1in
embargo, si se omite la segunda expresin, se asumir !ue esta tiene un valor permanente.
EJEMPLO >*
Cantidades enteras consecutivas revisado.
beamos otro ejemplo de un programa en C !ue genera los enteros consecutivos =,3,;,...,:. Cada uno de ellos en una
l)nea. ?tilizaremos a%ora una instruccin for en la !ue dos de las tres expresiones se %an omitido.
Einclude Fstdio.%G
main, / CDbisualizar los nmeros del = al :DC
A
int digitoJ=
for,' digitoFJ:'digito dd/
printf,IMdSnL,digito/'
B
Esta versin del programa es ms oscura !ue la !ue se mostr en el ejemplo anterior y por lo tanto menos deseable.
EJEMPLO > -
Con$#r%in d# (in?%cu)a% a (a@?%cu)a%.
-resentamos de nuevo un programa en C !ue convierte un texto de minsculas a maysculas. ea %emos visto otros
programas !ue %acen esto, en este caso %aremos uso de la instruccin for.
CD Este programa convierte una l)nea de texto de minsculas a maysculas usando la estructura for.DC
Einclude Fstdio.%G
Einclude Fctype.%G
Edefine E2L fSng
void main, /
44
A
c%ar letrasV9=Y'
int aux,cont'
CDLeer el texto en minsculasDC
for ,contJ=',letrasVcontYJgetc%ar, //RJE2L'ddcont/
'
auxJcont'
CDEscribir el texto en maysculasDC
for ,contJ='contFaux'ddcont/
putc%ar,toupper,letrasVcontY//'
B
4.4 S#nt#ncia% !r#aA @ continu#.
!r#aA y continu# permiten controlar la ejecucin de bucles 80i)# , 3or y do...80i)#
1e puede salir de un bucle directamente con !r#aA .
continu# va directamente al final del bucle y emprende una nueva iteracin.
Br#aA
>iene dos usos$
o para finalizar un case en una sentencia s+itc%.
o para forzar la terminacin inmediata de un bucle.
+%ile ,.../
A
...
...
brea['
...
B
Continu#
*ace comenzar la iteracin siguiente del bucle, saltando as) la secuencia de instrucciones comprendida entre el
continu# y el fin del bucle.
do A
scanf,"Md",Nnum/'
if ,xF=/ continue'
printf,"Md",x/'
B +%ile ,xRJ3==/'
+%ile ,.../
A
...
45
...
continue'
...
B
46
II PARTE
Unidad I: Buncion#%
1.1 Conc#&to d# Buncion#%
En C los mdulos se llaman funciones. -or lo general en C, los programas se escriben combinando nuevas funciones
!ue el programador escribe, con funciones IpreempacadasL, disponibles en la ilioteca estndar de !. La biblioteca
estndar de C contiene una amplia coleccin de funciones para llevar a cabo clculos matemticos comunes,
manipulaciones con cadenas, manipulaciones con caracteres, entradaCsalida, y muc%as otras operaciones tiles. Esto
facilita la tarea del programador, por!ue estas funciones proporcionan muc%as de las capacidades !ue los
programadores re!uieren.
Las funciones printf y scanf !ue %emos utilizados son funciones estndar de biblioteca.
El programador puede escribir funciones para definir tareas espec)ficas, !ue puedan ser utilizadas en muc%os puntos de
un programa. Estas a veces se conocen como funciones definidas por el programador. Los enunciados !ue definen la
funcin se escriben slo una vez, !uedando los enunciados ocultos de otras funciones.
Las funciones se invocan mediante una llamada de funcin. La llamada de funcin especifica el nombre de la
misma y proporciona informacin ,en forma de argumentos/, !ue la funcin llamada necesita a fin de llevar a
cabo su tarea designada. ?na analog)a comn de lo anterior es la administracin de tipo jerr!uico. ?n jefe
,la funcin !ue llama o el llamador/ le pide al trabajador ,la funcin llamada/ !ue ejecute una tarea y cuando
sta %aya sido efectuada, informe.
1.* E%tructura% d# )a% Buncion#%
0l emplear una funcin se ven involucrados tres elementos del programa$ la definicin de la funcin, la llamada a la
funcin y el prototipo de la funcin.
1.*.1 D#3inicin d# 3uncin.
1e denomina definicin de la funcin a la funcin propiamente dic%a. Cada programa !ue %emos presentado %a
consistido de una funcin llamada main, !ue para llevar a cabo sus tareas %a llamado funciones estndar de biblioteca.
beremos a%ora, como los programadores escriben sus propias funciones personalizadas.
La forma general de una funcin es$
tipo nombre ,tipo3 arg3, tipo; arg, h tipon argn/
A
h
B
*ay !ue %acer notar !ue la primera l)nea no finaliza con punto y coma.
tipo representa el tipo de dato del valor !ue devuelve la funcin y si la funcin no devuelve ningn valor se debe poner la
palabra reservada void.
nomre: representa el nombre de la funcin ,ver identificadores/.
ar"umentos$ !ue se denominan en la definicin de la funcin ar'u(#nto% 3or(a)#%, permiten la transferencia de
informacin desde el punto del programa en donde se llama a la funcin a sta. ,Los argumentos correspondientes en
la llamada a la funcin se denominan ar'u(#nto% actua)#% o r#a)#%/. Los identificadores utilizados como argumentos
formales son locales en el sentido de !ue no son reconocidos fuera de la funcin. Cada argumento formal debe tener el
47
mismo tipo de datos !ue el correspondiente argumento actual. Esto es, cada argumento formal debe ser del mismo tipo
!ue el dato !ue recibe desde elpunto de llamada.
El resto de la definicin de la funcin es una sentencia compuesta !ue define las acciones !ue debe realizar sta. 1e
suele llamar a esta sentencia cuerpo de la funcin.
1e devuelve informacin desde la funcin %asta el punto de llamada mediante la sentencia r#turn. La sentencia r#turn
tambin %ace !ue se devuelva el control al punto de llamada. En trminos generales se puede escribir la sentencia de la
siguiente forma$
r#turn #<&r#%in'
1e devuelve el valor de expresin al punto de llamada. La expresin es opcional y si se omite, la sentencia return
simplemente devuelve el control al punto del programa desde donde se llam a la funcin, sin ninguna transferencia de
informacin.
1olo se puede incluir una expresin en la sentencia return. -or tanto, una funcin slo puede devolver un valor al punto
de llamada mediante la sentencia return. -ara !ue la funcin devuelva ms de un valor es necesario otro mecanismo.
La definicin de una funcin puede ubicarse en cual!uier lugar del programa, con slo dos restricciones$ debe %allarse
luego de dar su prototipo y, y no puede estar dentro de la definicin de otra funcin ,incluida main,//.
E"#(&)o de una funcin !ue devuelve un valor entero largo.
long int factorial ,int n/
A
long int f J 3'
int .'
for ,i J ;' iFJn' ddi/
fDJ.'
return ,f/'
B
1.*.*. La ))a(ada o acc#%o a )a 3uncin
La llamada a una funcin se realiza de forma diferente, segn !ue la funcin devuelva o no un valor al punto de llamada.
1i la funcin no devuelve ningn valor ,void/ se accede a ella especificando su nombre, seguido de una lista de
argumentos encerrados entre parntesis y separados por comas.
1i la funcin devuelve un valor se debe acceder a ella desde una expresin.
En ambos casos si la funcin no re!uiere argumentos se deben especificar los parntesis vac)os.
Los argumentos actuales pueden ser constantes, variables o expresiones ms complejas. #o obstante cada argumento
actual debe ser del mismo tipo de datos !ue el argumento formal correspondiente.
E"#(&)o% d# ))a(ada a una 3uncin.
-ara el caso de la funcin factorial !ue devuelve un valor$
printf ,IEl factorial de Md es MldL, x, factorial ,x//'
fac J factorial ,x/'
a J a d factorial,x/'
if ,factorial,x/ F P=/
s+itc% ,factorial ,x/ /
48
1.*.-. Prototi&o d# )a 3uncin 9d#c)aracin:
Este el tercer elemento relacionado con una funcin. Est formado por una l)nea antes del comienzo de main,/. Esta
l)nea es igual !ue la primera l)nea de la definicin de la funcin, excepto por!ue termina con punto y coma y !ue el
nombre de los argumentos es excepcional.
El propsito es decirle al compilador el nombre de la funcin, el tipo de dato !ue devuelve la funcin ,si %ay alguno/ y el
nmero y tipo de los argumentos de la funcin ,si los %ay/.
Lo !ue %ay !ue recordar sobre el prototipo es !ue los tipos de datos del prototipo y de la definicin de la funcin debe
coincidir.
(ormalmente la declaracin de prototipo es$
tipo#de#valor#de#retorno nomre#de#la#funcin (lista de tipos de parmetros);
E"#(&)o
float mifuncion ,int i, double j/'
double otrafuncion, /'
otramas,/'
void lapenultimafuncion ,double z, c%ar y, int x/'
void laultima,/'
Ejemplo E3
Considere un programa !ue utiliza una funcin cuadrado para calcular los cuadrados de los nmeros enteros del 3 al 3=.
CD-rograma usando funciones definidas por el usuario para calcular los cuadrados de los enteros del 3 al 3=DC
Einclude Fstdio.%G
int cuadrado,int/' CD-rototipo de funcinDC
main,/
A
int x'
for ,xJ3'xFJ3='xdd/
printf,"Md ", cuadrado,x//'
printf,"Sn"/'
return =' B
CDHefinicin de la funcinDC
int cuadrado,int y/
A
return yDy'
B
La funcin cuadrado es invocada, o bien llamada en main dentro del enunciado printf
printf,IMd I, cuadrado,x//'
La funcin cuadrado recibe una copia del valor de x en el parmetro y. 0 continuacin cuadrado calcula yDy. El
resultado se regresa a la funcin printf en main donde se llam a cuadrado, y printf despliega el resultado. Este proceso
se repite diez veces utilizando la estructura de repeticin for.
La definicin de cuadrado muestra !ue cuadrado espera un parmetro entero y.
49
La palabra reservada int, !ue precede al nombre de la funcin indica !ue cuadrado regresa o devuelve un resultado
entero. El enunciado return en cuadrado pasa el resultado del clculo de regreso a la funcin llamadora.
La l)nea int cuadrado,int/' es un prototipo de funcin. El int dentro del parntesis informa al compilador !ue cuadrado
espera recibir del llamador un valor entero. El int a la iz!uierda del nombre de la funcin cuadrado le informa al
compilador !ue cuadrado regresa al llamador un resultado entero. El compilador %ace referencia al prototipo de la
funcin para verificar !ue las llamadas a cuadrado contengan el tipo de regreso correcto, el nmero correcto de
argumentos, el tipo correcto de argumentos, y !ue los argumentos estn en el orden correcto.
Ejemplo E;
CD-rograma usando funciones definidas por el usuario para
determinar el valor mximo de tres valores enterosDC
Einclude Fstdio.%G
int maximo,int,int,int/' CD-rototipo de funcinDC
void main,/
A
int a,b,c'
printf,"Escriba tres valores enteros$"/'
scanf,"MdMdMd", Na, Nb, Nc/'
printf,"El valor mximo es$ MdSn", maximo,a,b,c//'
B
CDHefinicin de la funcinDC
int maximo,int x, int y, int z/
A
int maxJx'
if ,yGmax/
maxJy'
if ,zGmax/
maxJz'
return max'
B
1.- AMBITO DE LAS VARIABLES
1.-.1 Varia!)#% C)o!a)#%
*asta a%ora %emos diferenciado a las variables segn su ItipoL ,int, c%ar, double, etc./, el cual se referencia en ltima
instancia a la cantidad de bytes !ue la conforman. beremos a%ora !ue %ay otra diferenciacin de las mismas, de
acuerdo a la clase de memoria en la !ue residen.
1i definimos una variable 0(?E70 de cual!uier funcin ,incluyendo main,//, estaremos frente a lo denominado
b07.06LE `L260L. Este tipo de variable ser ubicada en el segmento de datos de la memoria utilizada por el
programa y existir todo el tiempo !ue est ejecutndose este.
Este tipo de variable son automticamente inicializadas a CE72 cuando el programa comienza a ejecutarse.
1on accesible a todas las funciones !ue estn declaradas en el mismo, por lo !ue cual!uiera de ellas podr actuar sobre
el valor del mismo. -or ejemplo$
50
Ejemplo E3
Einclude Fstdio.%G
double unaWfuncion,/'
double variableWglobal'
void main,/
A
double i'
printf,"Mf",variableWglobal/'
i J unaWfuncion,/'
printf,"SnSnMf",i/'
variableWglobal dJ3'
printf,"SnSnMf",variableWglobal/'
B
double unaWfuncion,/
A
return variableWglobal dJ 3'
B
2bservemos !ue la variable global est definida afuera de las funciones del programa, incluyendo al main,/, por lo !ue le
pertenece a >2H01 ellas. En el primer printf,/ del programa principal se la imprime, demostrando !ue est
automticamente inicializada a cero.
Luego es incrementada por unaWfuncion,/ !ue devuelve adems un acopia de su valor, el cual es asignado a i, la !ue, si
es impresa mostrar un valor de uno, pero tambin la variableWglobal %a !uedado modificada, como lo demuestra la
ejecucin de la sentencia siguiente. Luego main,/ tambin modifica su valor, lo cual es demostrado por el printf,/
siguiente.
Esto nos permite deducir !ue dic%a variables es de uso pblico, sin !ue %aga falta !ue ninguna funcin la declare, para
actuar sobre ella.
-uede resultar muy dif)cil evaluar su estado en programas algo complejos, con mltiples llamados condicionales a
funciones !ue las afectan, dando comnmente origen a errores muy engorrosos de corregir.
1.-.* Varia!)#% Loca)#%
0 diferencia de las anteriores, las variables definidas HE#>72 de una funcin, son denominadas b07.06LE1
L2C0LE1, a la misma, a veces se las denomina 0?>2\0>.C01, ya !ue son creadas y destruidas automticamente por
la llamada y el retorno de una funcin, respectivamente.
Estas variables se ubican en la pila dinmica ,stac[/ de memoria, destinndosele un espacio en la misma cuando se las
define dentro de una funcin, y borrndose cuando la misma devuelve el control del programa a !uien se la %aya
invocado.
Este mtodo permite !ue, aun!ue se %aya definido un gran nmero de variables en un programa, estas no ocupen
memoria simultneamente en el tiempo, y solo vayan incrementando el stac[ cuando se las necesita, para luego, una
vez usadas desaparecer, dejando el stac[ en su estado original.
El identificador o nombres !ue se le %aya dado a una variable es slo relevante entonces, para la funcin !ue la %aya
definido pudiendo existir entonces variables !ue tengan el mismo nombre, pero definidas en funciones distinta, sin !ue
%aya peligro alguno de confusin.
La ubicacin de estas variables locales, se crea en el momento de correr el programa, por lo !ue no poseen una
direccin prefijada, esto impide !ue el compilador las pueda inicializar previamente. 7ecuerde entonces !ue, si no las
inicializa expresamente en el momento de su definicin, su valor ser indeterminado ,basura/.
51
Ejemplo
Einclude Fstdio.%G
CC-rograma !ue ejemplifica el uso de variables locales
int prueba,int/'
void main,/
A
int i, ['
for ,i J 3' iFJP'idd/
A
[ J prueba,i/'
printf,"SnMd", [/'
B
B
int prueba,int y/
A
int p J ='
p J y d p'
return p'
B
1.-.* Varia!)#% Loca)#% E%t2tica%
Las variables locales vistas %asta a%ora, nacen y mueren con cada llamada y finalizacin de una funcin, sin embargo
muc%as veces ser)a til !ue mantuvieran su valor, entre una y otra llamada a la funcin sin por ello perder su mbito de
existencia, es decir, seguir siendo locales slo a la funcin !ue la defina. En el siguiente ejemplo veremos !ue esto se
consigue definiendo a la variable con el prefijo %tatic.
Ejemplo
CC-rograma !ue ejemplifica el uso de variables locales E1>0>.C01
int prueba,int/'
void main,/
A
int i, ['
for ,i J 3' iFJP'idd/
A
[ J prueba,i/'
printf,"SnMd", [/'
B
B
int prueba,int y/
A
int static p J ='
p J y d p'
return p'
B
52
1.1 Conc#&to @ u%o d# Buncion#% Mat#(2tica% d# !i!)iot#ca.
Las funciones matemticas de biblioteca le permiten al programador ejecutar ciertos clculos matemticos comunes.
-ara iniciarnos en el concepto de las funciones utilizamos a!u) varias funciones matemticas de biblioteca
Las funciones se utilizan normalmente en un programa, escribiendo el nombre de la funcin, seguido por un parntesis
iz!uierdo y a continuacin por el argumento ,o una lista de argumentos separados por comas/, de la funcin seguida por
un parntesis derec%o. -or ejemplo, un programador !ue desea calcular e imprimir la ra)z cuadrada de :==.= pudiera
escribir$
printf,IM.;fL, s!rt,:==.=//'
Cuando este enunciado se ejecuta, es llamada la funcin matemtica de biblioteca s!rt, a fin de !ue calcule la ra)z
cuadrada del nmero contenido entre parntesis ,:==.=/. El nmero :==.= es el argumento de la funcin s!rt. El
enunciado anterior imprimir <=.==. La funcin s!rt toma un argumento del tipo double y regresa un resultado del tipo
double. >odas las funciones de la biblioteca de matemticas devuelven el tipo de datos double.
Cuando est utilizando funciones de la biblioteca de matemticas incluya el arc%ivo de cabecera de matemtica
utilizando la directriz de preprocesador Einclude Fmat%.%G.
Los argumentos de las funciones pueden ser constantes, variables o expresiones. 1i c3J3<.=, dJ<.=, y fJO.=, entonces
el enunciado
printf,IM.;fL, s!rt,c3ddDf//'
Calcula e imprime la ra)z cuadrada de 3<.=d<.=DO.=J;P.=, es decir P.==.
1. 4 R#cur%i$idad
Este tema se aborda de forma ligera, puesto !ue su estudio y aplicacin re!uieren de mayor tiempo y %erramientas. En
el presente cap)tulo abordaremos el tema de forma introductoria.
Es la propiedad de un lenguaje de programacin !ue permite a una funcin o procedimiento llamarse a si mismo para
volver a ejecutar su cdigo en una instancia distinta.
El concepto de recursividad va ligado al de repeticin. 1on recursivos a!uellos algoritmos !ue, estando encapsulados
dentro de una funcin, son llamados desde ella misma una y otra vez, en contraposicin a los algoritmos iterativos, !ue
%acen uso de bucles +%ile, do&+%ile, for, etc.
0lgo es recursivo si se define en trminos de s) mismo ,cuando para definirse %ace mencin a s) mismo/. -ara !ue una
definicin recursiva sea vlida, la referencia a s) misma debe ser relativamente ms sencilla !ue el caso considerado.
E"#(&)o$ Hefinicin de n^ natural$
&Gel # ^ = es natural
&G El #^ n es natural si n&3 lo es.
1.4 R#%u(#n
?na funcin es una parte de un cdigo independiente de la funcin principal ,main/ y de otras funciones !ue puede ser
llamada o referenciada envindole datos ,o sin enviarle nada/, para !ue realice una determinada tarea yCo proporcione
unos resultados. Las funciones son una parte muy importante dentro del Lenguaje C.
53
1on una parte esencial del correcto dise8o de un programa de computadora en su modularidad, esto se refiere a su
divisin en partes ms pe!ue8as. Las funciones facilitan el desarrollo y mantenimiento de los programas, evitan errores,
y a%orran memoria, y trabajo innecesario. ?na funcin puede ser utilizada por distintos programas y por ende no es
necesario reescribirla. ?na funcin es una parte de cdigo independiente de la funcin principal y de otras funciones,
manteniendo una gran independencia entre las variables respectivas evitando errores y otros efectos colaterales de las
modificaciones !ue se introducen.
\ediante el uso de funciones se consigue un cdigo limpio, claro y elegante. La adecuada divisin de un programa en
funciones constituye un aspecto fundamental en el desarrollo de programas de cual!uier tipo. Las funciones ya
compiladas pueden guardarse en libreras
1.7 Auto#$a)uacin
3. Construya una funcin !ue acepte dos argumentos enteros llamados a y b y retorne la suma de ellos.
;. Construya una funcin !ue acepte un argumento coma flotante llamado base y otro entero llamado exponente,
deber devolver el primero elevado a la potencia del segundo. ,#o utilizar funciones de biblioteca/
<. Construya una funcin !ue no reciba argumentos ni devuelva valor alguno, solo deber imprimir el mensaje
I-0?10&C0(iL.
O. (uncin !ue recibe tres argumentos enteros llamados x, y, z y devuelve el mayor de ellos.
P. (uncin !ue retorne el cdigo 01C.. del argumento c%ar llamado letra.
4. (uncin !ue acepten un argumento c%ar llamado c y deber devolver el sucesor de dic%o argumento.
5. (uncin !ue calcule el rea de un cuadrado para ello recibe un argumento flotante llamado l.
9. (uncin !ue recibe dos argumentos enteros llamados a y b y devuelve el cociente de ambos.
:. funcin !ue acepta las notas de los < exmenes parciales y la nota del examen final, deber imprimir un
mensaje indicando si el alumno aprob o reprob la asignatura ,la funcin no retorna valor/.
3=. (uncin !ue acepta dos argumentos enteros llamados s y t, deber imprimir el mensaje I1ignos 2puestosL, si y
solo si, uno de los argumentos es negativo y el otro positivo.
54
$nidad %%& 'rre"los
*.1 Introduccin
>odas las variables !ue se %an considerado %asta a%ora son de tipo simple. ?na variable de tipo simple consiste de una
sola posicin de memoria y slo puede contener un valor cada vez. ?na variable de tipo estructurado consiste en toda
una coleccin de casillas de memoria. Los tipos de datos estudiados$ entero, real, c%ar, double son considerados como
datos de tipo simple, puesto !ue una variable !ue se define con alguno de estos tipos slo puede almacenar un valor a la
vez, es decir, existe una relacin de uno a uno entre la variable y el nmero de elementos ,valores/ !ue es capaz de
almacenar. En cambio un dato de tipo estructurado, como el arreglo, puede almacenar ms de un elemento ,valor/ a la
vez, con la condicin de !ue todos los elementos deben ser del mismo tipo, es decir, !ue se puede tener un conjunto de
datos enteros, float, etc.
-ara iniciar el estudio de los arreglos es necesario definir los siguientes trminos$
Dato% #%tructurado%:
Estructura de Hatos es una coleccin de datos !ue se caracterizan por su organizacin y las operaciones !ue se definen
en ella. Los datos de tipo estndar pueden ser organizados en diferentes estructuras de datos$ estticas y dinmicas.
E%tructura d# Dato% #%t2tica%$
1on a!uellas en las !ue el espacio ocupado en memoria se define en tiempo de compilacin y no puede ser
modificado durante la ejecucin del programa. Corresponden a este tipo los arrays y registros
E%tructura% d# Dato% Din2(ica%:
1on a!uellas en las !ue el espacio ocupado en memoria puede ser modificado en tiempo de ejecucin.
Corresponden a este tipo las listas, rboles y grafos. Estas estructuras no son soportadas en todos los
lenguajes de programacin. La eleccin de la estructura de datos idnea depender de la naturaleza del
problema a resolver y, en menor medida, del lenguaje de programacin. Las estructuras de datos tienen en
comn !ue un identificador, nombre, puede representar a mltiples datos individuales.
Los arreglos, arrays en ingls, son uno de los factores esenciales de los programas de computadora. -ermiten !ue se
%aga referencia a entradas individuales en una tabla de elementos de datos usando el mismo cdigo y variando el )ndice
del elemento.
*.* Conc#&to d# Arr#')o%
?n array es una coleccin de variables del mismo tipo !ue se referencian por un nombre comn. 0 un elemento
espec)fico de un arrays se accede mediante un )ndice. En C todos los arrays constan de posiciones de memoria
contiguas. La direccin ms baja corresponde al primer elemento y la ms alta al ltimo. Los arrays pueden tener una o
varias dimensiones. El array ms comn en C es la cadena, !ue simplemente es un array de caracteres terminado por
uno nulo.
Por 5uD U%ar )o% Arr#')o%E
-or !ue son uno de los factores esenciales de los programas de computadora. -ermiten !ue se %aga referencia a
entradas individuales en una tabla de elementos de datos usando el mismo cdigo y variando el )ndice del elemento.
La cantidad total de espacio !ue se usa por un arreglo depende de ; cosas$ El nmero de elementos en el arreglo y el
tipo de datos de los elementos del arreglo.
55
*.- Arr#')o% Unidi(#n%iona)#%
Los arrays unidimensionales son listas de informacin del mismo tipo !ue se guardan en posiciones contiguas de
memoria segn el orden del )ndice. La forma general de declaracin es$
tipo nomre#variale (tama)o*;
Los arrays tienen !ue declararse impl)citamente para !ue el compilador reserve espacio en memoria para ellos. El tipo
declara el tipo de los elementos del array, el tama)o indica cuntos elementos mantendr el array.
-ara declarar un array de 3= elementos denominado p y de tipo carcter, se escribe$
char p(1+*;
En este caso %emos declarado un array !ue tiene diez elementos, desde p(+* %asta p(,*.
En C todos los arrays tienen el = como )ndice de su primer elemento.
La forma como pueden ser accesados los elementos de un arreglo, es de la siguiente forma$
listanumV;Y J 3P' CD 0signa 3P al <er elemento del arreglo listanumDC
num J listanumV;Y' CD 0signa el contenido del <er elemento a la variable num DC
C no comprueba los l)mites de los arrays. 1e puede pasar cual!uier extremo de un array y escribir en alguna otra
variable de datos e incluso en el cdigo del programa.
56
E"#(&)o
CD ?tilizacin de arreglos.
-rograma !ue cuenta cuntas veces se repite cada d)gito,
cada carcter separador, y otros caracteres. DC
Einclude Fstdio.%G
Edefine #H 3=
void main,/
A
int c, i, n_%ite J =, n2t%er J =, nHigitV#HY'
for,i J =' i F #H' idd/
nHigitViY J ='
+%ile,,c J getc%ar,// RJ E2(/
if,c GJ j=j NN c FJ j:j/
nHigitVc & j=jYdd'
else
if,c JJ j j kk c JJ jSnj kk c JJ jStj/
n_%itedd'
else
n2t%erdd'
for,i J =' i F #H' idd/
printf,"H)gito Md$ MdSn",i,nHigitViY/'
printf,"Caracteres separadores$ MdSn",n_%ite/'
printf,"2tros caracteres$ MdSn",n2t%er/'
B
*.1 Inicia)iFacin d# arra@%
C permite la inicializacin de arrays al momento de declararlos, como en cual!uier variable. La forma general es$
tipo nomre (tama)o1* - (tama)o n*./lista de valores0;
la lista de valores es una lista de constantes separadas por comas cuyo tipo es compatible con el tipo especificado en la
declaracin del array. -or ejemplo$
int i(1+* . /1121312131415161,11+0;
Con las cadenas o arrays de caracteres se %ace igual, aun!ue permite una inicializacin abreviada.
Estas dos sentencias producen el mismo resultado$
c%ar cadV33Y J "\e gusta C"'
c%ar cadV33Y J Af\g,geg,g f,ggg,gug,gsg,gtg,gag,g f,gCg,gS=gB'
Los arrays multidimensionales se inicializan del mismo modo !ue los unidimensionales.
*.4 Arr#')o% d# Caract#r#% @.o Cad#na% d# Caract#r#%
El uso ms comn de los arrays unidimensionales es como cadenas de caracteres. En C una cadena se define como
un array de caracteres !ue termina en un carcter nulo ,fS=g/.
57
-ara declarar un array de caracteres es necesario un carcter ms !ue la cadena ms larga !ue pueda contener, para
dejar sitio para el carcter nulo del final de la cadena.
?na constante de cadena es una lista de caracteres encerrada entre dobles comillas. -or ejemplo$ "%ola, !ue tal"
#o es necesario a8adir expl)citamente el carcter nulo al final de las constantes de cadena, el compilador lo %ace
automticamente.
-ara asignar la entrada estndar a una cadena se puede usar la funcin scanf con la opcin 7s ,observar !ue no se
re!uiere usar el operador 8/, de igual forma para mostrarlo en la salida estndar.
-or ejemplo$
EincludeFstdio.%G
void main,/
A
c%ar nombreV3PY, apellidosV<=Y'
printf,".ntroduce tu nombre$ "/'
scanf,"Ms",nombre/'
printf,".ntroduce tus apellidos$ "/'
scanf,"Ms",apellidos/'
printf,"?sted es Ms MsSn",nombre,apellidos/'
B
El lenguaje C no maneja cadenas de caracteres, como se %ace con enteros o flotantes, por lo !ue lo siguiente no es
vlido$
EincludeFstdio.%G
main,/ A
c%ar nombreVO=Y, apellidosVO=Y, completoV9=Y'
nombreJ"los \ar)a"' CD .legal DC
apellidosJ"\oralos y -avn"' CD .legal DC
completoJ"`ral."dnombredapellidos' CD .legal DC
B
*.7 Arra@% (u)tidi(#n%iona)#%
C permite arrays de ms de una dimensin. La forma general de declaracin de un array multidimensional es$
9ipo nomre (a* (* (c* ::: (;*;
Los arrays de tres o ms dimensiones no se utilizan a menudo por la cantidad de memoria !ue se re!uiere para
almacenarlos, ya !ue el almacenamiento re!uerido aumenta exponencialmente con el nmero de dimensiones.
-ara acceder los elementos se procede de forma similar al ejemplo del arreglo unidimensional, esto es,
tabladenumsV;YV<Y J 3P' CD 0signa 3P al elemento de la <m fila y la Om columnaDC
num J tabladenumsV;PYV34Y'
0 continuacin se muestra un ejemplo !ue asigna al primer elemento de un arreglo bidimensional cero, al siguiente 3,
y as) sucesivamente.
58
EincludeFstdio.%G
void main,/ A
int t,i,numV<YVOY'
for,tJ=' tF<' ddt/
for,iJ=' iFO' ddi/
numVtYViYJ,tDO/diD3'
for,tJ=' tF<' ddt/
A
for,iJ=' iFO' ddi/
printf,"numVMdYVMdYJ Md ", t,i,numVtYViY/'
printf,"Sn"/'
B
B
*.G Uti)iFacin d# arr#')o% co(o &ar2(#tro%
Cuando se usa un arreglo como un argumento a la funcin, se pasa slo la direccin del arreglo y no la copia del
arreglo entero. -ara fines prcticos podemos considerar el nombre del arreglo sin ningn )ndice como la direccin del
arreglo.
Considere el siguiente ejemplo en donde se pasa un arreglo a la funcin imp_rev, observe !ue no es necesario
especificar la dimensin del arreglo cuando es un parmetro de la funcin.
EincludeFstdio.%G
EincludeFstring.%G
void impWrev,c%ar sVY/
A
int t'
for, tJstrlen,s/&3' tGJ=' t && /
printf,"Mc",sVtY/'
B
void main,/
A
c%ar nombreVYJ"Escuela de Ciencias de la Computacin"'
impWrev,nombre/'
B
2bservar !ue en la funcin imp#rev se usa la funcin strlen para calcular la longitud de la cadena sin incluir el
terminador nulo. -or otra parte, la funcin imp#rev no usa la sentencia return ni para terminar de usar la funcin, ni
para regresar algn valor.
2tro ejemplo,
EincludeFstdio.%G
float enconprom,int tam, float listaVY/
A
int i'
float suma J =.='
for , iJ=' iFtam' idd/
suma dJ listaViY'
return,sumaCtam/'
59
B
void main,/
A
float numerosVYJA;.<, 9.=, 3P.=, ;=.;, OO.=3, &<.=, &;.:B'
printf,"El promedio de la lista es MfSn", enconprom,5,numeros/ /'
B
-ara el caso de !ue se tenga !ue pasar un arreglo con ms de una dimensin, no se indica la primera dimensin
pero, el resto de las dimensiones deben se8alarse.
0 continuacin otro ejemplo$
void imprtabla,int tamx, int tamy, float tablaVYVPY/
A
int x,y'
for , xJ=' xFtamx' xdd /
A
for , yJ=' yFtamy' ydd /
printf,"tVMdYVMdYJMf",x,y,tablaVxYVyY/'
printf,"Sn"/'
B
B
*.H R#%u(#n
?n arreglo est formado por un nmero fijo de elementos contiguos de un mismo tipo. 0l tipo se le llama tipo base del
arreglo. Los datos individuales se llaman elementos del arreglo.
-ara definir un tipo estructurado arreglo, se debe especificar el tipo base y el nmero de elementos.
?n array se caracteriza por $
0lmacenar los elementos del array en posiciones de memoria continuas
>ener un nico nombre de variable !ue representa a todos los elementos, y stos a su vez se diferencian por
un )ndice o sub)ndice.
0cceso directo o aleatorio a los elementos individuales del array.
Los arrays se clasifican en $
?nidimensionales ,vectores o listas/
\ultidimensionales , tablas o matrices/

V#nta"a% @ d#%$#nta"a% d# u%ar arr#')o%:
1i conocemos la posicin dentro del arreglo del elemento !ue !ueremos consultar, la consulta toma un
tiempo constante.
-ueden ser usados para implementar otras estructuras de datos sofisticadas como pilas, colas, tablas
%as%.
60
1u tama8o es fijo, por lo !ue si no se conoce de antemano el nmero mximo de elemento a almacenar
pueden ocurrir problemas si el espacio reservado es menor del necesario.
.nsertar elementos de manera ordenada es muy lento.
6uscar un elemento en un arreglo desordenado es muy lento.
61
7epresentacin grfica de arreglos
62
*.I Auto#$a)uacin
3. He un conjunto de # nmeros ingresados imprimir la suma de los valores mayores a P=.
;. Escribir una funcin IreemplazaL, la cual toma una cadena como parmetro, le reemplaza todos los espacios
de la cadena por un guin bajo, y devuelve el nmero de espacios reemplazados. -or ejemplo$
c%ar cadenaVY J "El gato negro"'
n J reemplaza, cadena /'
deber devolver$
cadena convertida "ElWgatoWnegro"
n J ;
<. Escribir un programa !ue lea una l)nea de texto ,una cadena de caracteres/ usando la funcin "ets y calcule
la longitud de la l)nea ,#2 usar la funcin strlen/.
O. Escribir un programa para leer un texto %asta el fin&de&datos, y mostrar una estad)stica de las longitudes de
las palabras, esto es, el nmero total de palabras de longitud 3 !ue %ayan ocurrido, el total de longitud ; y
as) sucesivamente.
Hefine una palabra como una secuencia de caracteres alfabticos. 1e debern permitir palabras %asta
de una longitud de ;P letras.
?na salida t)pica podr)a ser como esta$
longitud 3 $ 34 ocurrencias
longitud ; $ ;= ocurrencias
longitud < $ P ocurrencias
longitud O $ ; ocurrencias
longitud P $ = ocurrencias
........
P. Compile y corra el siguiente programa y expli!ue lo !ue ocurre$
Einclude Fstdio.%G
void main,/A
int aVOY J A=, 3, ;, <B'
int bVOY J AO, P, 4, 5B'
int i'
for ,iJ=' iF9' idd/
printf ,"aVMdY J MdSn",i,aViY/'
B
63
$nidad %%%& Estructuras
-.1 Introduccin
En muc%as ocasiones es necesario disponer de variables compuestas de otras variables y trabajar con ellas como si
se tratasen de una sola. ?n ejemplo t)pico es una fic%a de datos de una agenda. #ecesitar)amos una variable !ue nos
almacenase el nombre, otra variable !ue nos almacenase la direccin, otra para el telfono y as) sucesivamente para
todos los datos !ue deseemos mantener. -odr)amos disponer de una variable para cada campo ,cada una de las
informaciones !ue componen nuestra fic%a/ pero esto resultar)a un tanto engorroso a la %ora de su programacin.
El lenguaje C dispone de mecanismos para trabajar con variables compuestas de otras variables con suma
facilidad. Existen dos tipos bsicos$ estructuras y uniones.
Las Estructuras de datos son la forma ms verstil de trabajar con fic%as de informacin. .niciaremos el estudio
primeramente con la definicin y posteriormente abordaremos todos los aspectos relevantes de ellas.
-.* D#3inicin d# #%tructura%
Las estructuras son colecciones de variables relacionadas @a veces llamadas agregados& bajo un nombre. Las
estructuras pueden contener variables de muc%os tipos diferentes de datos @a diferencia de los arreglos, contienen
nicamente elementos de un mismo tipo de datos. `eneralmente las estructuras se utilizan para definir registros a
almacenarse en arc%ivos. Los apuntadores y las estructuras facilitan la formacin de estructuras de datos de mayor
complejidad, como son las listas enlazadas, colas de esperas, pilas y rboles.
Las estructuras son tipos de datos derivados @estn construidas utilizando objetos de otros tipos. Considere la siguiente
definicin de estructura$
struct personal
A
c%ar nombre V3PY'
c%ar apellido V3PY'
float salario'
B'
La palabra reservada %truct presenta la definicin de estructura. El identificador &#r%ona) es el rtulo de la estructura.
El rtulo de la estructura da nombre a la definicin de la misma, y se utiliza con la palabra reservada %truct para declarar
variables del tipo estructura. En este ejemplo, el tipo de estructura es %truct &#r%ona). Las variables declaradas dentro
de las llaves de la definicin de estructura son los miembros de la estructura. Los miembros de la misma estructura
deben tener nombres nicos, pero dos estructuras diferentes pueden contener miembros con el mismo nombre sin entrar
en conflicto. Cada definicin de estructura debe terminar con un punto y coma.
La definicin %truct &#r%ona) contiene tres miembros del tipo c%ar y float. Los miembros de la estructura pueden ser
variables de los tipos de datos bsicos ,es decir, int, float, c%ar, etc/, o agregados o estructurados, como son los arreglos
y otras estructuras. Los miembros de una estructura pueden ser de una variedad de tipos. ?na estructura no puede
contener una instancia de si misma. -or ejemplo, una variable del tipo %truct &#r%ona) no puede ser declarada dentro
de la definicin correspondiente a %truct &#r%ona).
La definicin anterior de estructura no reserva ningn espacio de memoria, ms bien genera un nuevo tipo de datos, !ue
se utiliza para declarar variables. Las variables de estructuras se declaran como se declaran las variables de otros tipos.
La declaracin
%truct &#r%ona) E= P#r%ona)DJ14K= /cL
64
declara E ser una variable de tipo %truct &#r%ona), declara -ersonalH como un arreglo de O; elementos del tipo %truct
&#r%ona), y declara c como un apuntador a %truct &#r%ona). Las variables de un tipo dado de estructura, pudieran
tambin ser declaradas colocando una lista separadas por comas, de los nombres de las variables, entre la llave de
cierre de la definicin de la estructura y el punto y como !ue termina la definicin de la misma. -or ejemplo, la
declaracin anterior pod)a %aberse incorporado en la definicin de estructura
%truct &#r%ona) como sigue$
struct personal A
c%ar nombre V3PY'
c%ar apellido V3PY'
float salario'
B E, -ersonalHVO;Y, Dc'
El nombre del rtulo de la estructura es opcional. 1i la definicin de una estructura no contiene un nombre de rtulo de
estructura, las variables de ese tipo de estructura pueden ser nicamente declaradas dentro de la definicin de
estructura &y no en una declaracin por separado.
Las nicas operaciones vlidas !ue pueden ejecutarse sobre estructuras son$ asignar variables de estructura a variables
de estructura del mismo tipo, tomando la direccin ,N/ de una variable de estructura, obteniendo acceso a los miembros
de una variable de estructura y utilizando el operador sizeof, a fin de determinar el tama8o de la variable de estructura.
Las estructuras no pueden compararse entre si, por!ue los miembros de las estructuras no estn necesariamente
almacenados en byte de memoria consecutivos.
-.- Inicia)iFacin d# #%tructura%
Las estructuras pueden ser inicializadas mediante listas de inicializacin como con los arreglos. -ara inicializar una
estructura, escriba en la declaracin de la estructura, a continuacin del nombre de la variable, un signo igual, con
inicializadores encerrados entre llaves y separados por comas. -or ejemplo, la declaracin$
%truct &#r%ona) E M NOJuanP= OPDr#FP=1*-14.HIQL
crea la variable E de tipo %truct &#r%ona) ,como fue definida anteriormente/ e inicializa el miembro nombre a IluanL, el
miembro 0pellido a I-rezL y el miembro salario a 3;<OP.9:.
1i en la lista aparecen menos inicializadores !ue en la estructura, los miembros restantes automticamente !uedarn
inicializados a = ,o #?LL si el miembro es un apuntador/
-.1 Acc#%o a )o% (i#(!ro% d# #%tructura%
-ara tener acceso a miembros de estructuras se utilizan dos operadores$ el operador de miembro de estructura ,./ @
tambin conocido como operador punto y el operador de apuntador de estructura ,&G/ tambin conocido como opeador
de flec%a. El operador de miembro de estructura tiene acceso a un miembro de estructura mediante el nombre de la
variable de estructura. -or ejemplo para imprimir el miembro nombre de la estructura E correspondiente a la declaracin
anterior, se utiliza el enunciado$
printf,IMsL , E.nombre/'
-odemos realizar todas las operaciones %abituales de las variables$ asignacin, uso de punteros, llamadas a funciones
con el campo como parmetro$
struct complejo z J A3,3B'
printf,"z vale Mf, iMfSn", F.<= F.@/'
65
F.< M F.@ M RL
-.1.1 t@&#d#3
La palabra reservada typedef proporciona un mecanismo para la creacin de sinnimos ,o alias/ para tipos de datos
anteriormente definidos. Los nombres de los tipos de estructuras se definen ocasionalmente utilizando typedef, a fin de
crear nombres de tipos ms breves. -or ejemplo la siguiente definicin$
typedef struct A
c%ar nombre V3PY'
c%ar apellido V3PY'
float salario'
B personal'
crea el tipo de estructura personal, sin necesidad de un enunciado typedef por separado. personal puede a%ora ser
utilizado para declarar variables del tipo struct personal. La declaracin
personal 0dministrativoVP=Y'
declara un arreglo de P= estructuras personal ,es decir, variables del tipo struct personal/. 0l crear un nuevo nombre
utilizando typedef no se crea un nuevo tipo simplemente crea un nuevo nombre de tipo, !ue puede ser utilizado como
seudnimo para un nombre de tipo existente.
E"#(&)o%
CDEl presente programa %ace uso de variables de tipo estructura para almacenar los datos personales de ciertos
empleados, realizar algunos clculos e imprimir ciertos resultadosDC
EincludeFstdio.%G
struct personalA c%ar nombreV3PY'
c%ar apellidoV3PY'
int edad'
float salario6'
float incentivo'
float sueldo' B'
void main,/ A
struct personal personalWH' CCHeclaracion de la variable
CCLectura de Hatos
printf,".ntroduzca los datos para el personal docenteSn"/'
printf,"SnSt#ombre&&&&G "/'
scanf,"Ms",personalWH.nombre/'
printf,"SnSt0pellido&&&&G "/'
scanf,"Ms",personalWH.apellido/'
printf,"SnStEdad&&&&G "/'
scanf,"Md",NpersonalWH.edad/'
printf,"SnSt1alario 6sico&&&&G "/'
scanf,"Mf",NpersonalWH.salario6/'
66
CCClculos
personalWH.sueldo J personalWH.salario6 d .3P DpersonalWH.salario6'
if ,personalWH.edad GJ OP/
personalWH.incentivoJ OP='
else
personalWH.incentivoJ 3P='
personalWH.sueldo J personalWH.sueldodpersonalWH.incentivo'
CC.mpresin de Hatos
printf,"SnSnLos datos del -ersonal Hocente son$Sn"/'
printf,"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"/'
printf,"SnSt#ombre&&&&G Ms",personalWH.nombre/'
printf,"SnSt0pellido&&&&GMs ",personalWH.apellido/'
printf,"SnStEdad&&&&G Md",personalWH.edad/'
printf,"SnSt1alario 6sico&&&&G Mf",personalWH.salario6/'
printf,"SnSt.ncentivo&&&&G Mf",personalWH.incentivo/'
printf,"SnSt1ueldo >otal&&&&G Mf",personalWH.sueldo/'
B
-.4 Arr#')o d# E%tructura%
Cuando abordamos el tema de arreglos dijimos !ue se pod)an agrupar, para formar cual!uier tipo de variables, esto es
extensible a las estructuras y podemos entonces agruparlas ordenadamente, como elementos de un arreglo. beamos un
ejemplo$
typedef struct A
c%ar materialVP=Y '
int existencia '
double costoWunitario '
B .tem'
.tem stoc[V3==Y '
*emos definido a!u) un arreglo de 3== elementos, donde cada uno de ellos es una estructura del tipo .tem compuesta
por tres variables, un int, un double y un string o arreglo de P= caracteres.
Los arreglos de estructuras pueden inicializarse de la manera %abitual.
E"#(&)o *
CDEl presente programa %ace uso de un arreglo de estructuras el patron de la estructura es personal y la variable se llama
personalWH, la !ue contendr n elementos, donde cada elemento es una estructuraDC
EincludeFstdio.%G
Edefine n ;
struct personalA c%ar nombreV3PY'
c%ar apellidoV3PY'
int edad'
float salario6'
float incentivo'
float sueldo'
B'
67
void main,/
A
int i'
struct personal personalWHVnY' CCHeclaracion de la variable
CCLectura de Hatos
printf,".ntroduzca los datos para el personal docente Sn"/'
for ,iJ='iFn'idd/
A
printf,"Sn.ntroduzca los datos del Hocente nmero &&GMd$ Sn",id3/'
printf,"SnSt#ombre&&&&G "/'
scanf,"Ms",personalWHViY.nombre/'
printf,"SnSt0pellido&&&&G "/'
scanf,"Ms",personalWHViY.apellido/'
printf,"SnStEdad&&&&G "/'
scanf,"Md",NpersonalWHViY.edad/'
printf,"SnSt1alario 6sico&&&&G "/'
scanf,"Mf",NpersonalWHViY.salario6/'
B
CCClculos
for ,iJ='iFn'idd/
A
personalWHViY.sueldo J personalWHViY.salario6 d .3P DpersonalWHViY.salario6'
if ,personalWHViY.edad GJ OP/
personalWHViY.incentivoJ OP='
else
personalWHViY.incentivoJ 3P='
personalWHViY.sueldo J personalWHViY.sueldodpersonalWHViY.incentivo'
B
CC.mpresin de Hatos
for ,iJ='iFn'idd/ A
printf,"SnHatos del Hocente nmero &&GMd$ Sn",id3/'
printf,"SnSnLos datos del -ersonal Hocente son$Sn"/'
printf,"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"/'
printf,"SnSt#ombre&&&&G Ms",personalWHViY.nombre/'
printf,"SnSt0pellido&&&&GMs ",personalWHViY.apellido/'
printf,"SnStEdad&&&&G Md",personalWHViY.edad/'
printf,"SnSt1alario 6sico&&&&G Mf",personalWHViY.salario6/'
printf,"SnSt.ncentivo&&&&G Mf",personalWHViY.incentivo/'
printf,"SnSt1ueldo >otal&&&&G Mf",personalWHViY.sueldo/' B B
-.7 E%tructura% anidada%
>ambin est permitido anidar estructuras, con lo cual se pueden conseguir superestructuras muy elaboradas.
struct stHireccion A
c%ar CalleV4OY'
int -ortal'
int -iso'
68
c%ar -uertaV<Y'
c%ar Codigo-ostalV4Y'
c%ar -oblacionV<;Y'
B'

struct st-ersona A
struct st#ombre A
c%ar #ombreV<;Y'
c%ar 0pellidosV4OY'
B #ombreCompleto'
stHireccion Hireccion'
c%ar >elefonoV3=Y'
B'
En general, no es una prctica corriente definir estructuras dentro de estructuras, ya !ue resultan tener un mbito local, y
para acceder a ellas se necesita %acer referencia a la estructura ms externa.
E"#(&)o -
CDEl presente programa %ace uso de una estructura en cuyo patron ,personal/ incluye una variable !ue se llama
fec%aWnac la !ue es de tipo estructura ,fec%a/DC
EincludeFstdio.%G
Edefine n ;
Edefine actual ;==;
struct fec%aA int d'
int m'
int a' B'
struct personalA c%ar nombreV3PY'
c%ar apellidoV3PY'
int edad'
float salario6'
float incentivo'
float sueldo'
struct fec%a fec%aWn' B'
void main,/
A
int i'
struct personal personalWHVnY' CCHeclaracion de la variable
CCLectura de Hatos
printf,".ntroduzca los datos para el personal docente Sn"/'
for ,iJ='iFn'idd/
A
printf,"Sn.ntroduzca los datos del Hocente nmero &&GMd$ Sn",id3/'
printf,"SnSt#ombre&&&&G "/'
scanf,"Ms",personalWHViY.nombre/'
printf,"SnSt0pellido&&&&G "/'
scanf,"Ms",personalWHViY.apellido/'
printf,"SnSt1alario 6sico&&&&G "/'
scanf,"Mf",NpersonalWHViY.salario6/'
69
printf,"SnSt .ntroduzca la fec%a de nacimiento ,dato por dato/Sn"/'
printf,"SnH.0&&G$ "/'
scanf,"Md",NpersonalWHViY.fec%aWn.d/'
printf,"Sn\E1&&G$ "/'
scanf,"Md",NpersonalWHViY.fec%aWn.m/'
printf,"Sn0n2&&G$ "/'
scanf,"Md",NpersonalWHViY.fec%aWn.a/'
B
CCClculos
for ,iJ='iFn'idd/
A
personalWHViY.sueldo J personalWHViY.salario6 d .3P DpersonalWHViY.salario6'
if ,personalWHViY.edad GJ OP/
personalWHViY.incentivoJ OP='
else
personalWHViY.incentivoJ 3P='
personalWHViY.sueldo J personalWHViY.sueldodpersonalWHViY.incentivo'
personalWHViY.edad Jactual & personalWHViY.fec%aWn.a'
B
CC.mpresin de Hatos
for ,iJ='iFn'idd/
A
printf,"SnHatos del Hocente nmero &&GMd$ Sn",id3/'
printf,"SnSnLos datos del -ersonal Hocente son$Sn"/'
printf,"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"/'
printf,"SnSt#ombre&&&&G Ms",personalWHViY.nombre/'
printf,"SnSt0pellido&&&&GMs ",personalWHViY.apellido/'
printf,"SnStEdad&&&&G Md",personalWHViY.edad/'
printf,"SnSt1alario 6sico&&&&G Mf",personalWHViY.salario6/'
printf,"SnSt.ncentivo&&&&G Mf",personalWHViY.incentivo/'
printf,"SnSt1ueldo >otal&&&&G Mf",personalWHViY.sueldo/'
printf,"SnSt(ec%a de nacimiento&&&G MdCMdC
Md",personalWHViY.fec%aWn.d,personalWHViY.fec%aWn.m,personalWHViY.fec%aWn.a/'
B
B
-.G Uti)iFacin d# #%tructura% co(o &ar2(#tro%.
Las estructuras pueden ser pasadas a funciones pasando
miembros de estructuras individuales,
pasando toda la estructura, o
pasando un apuntador a una estructura.
Cuando se pasan estructuras o miembros individuales de estructura a una funcin, si estos se pasan en llamada por
valor, los miembros de la estructura de un llamador no podr)an ser modificados por la funcin llamada.

70
Hado !ue las estructuras tienen a por lo general un tama8o considerable se recomienda pasarlas a travs de punteros.
-ara obtener la direccin donde se %alla una estructura usaremos el operador direccin N, como con una variable
normal. -ara definir un puntero a una estructura usaremos el operador D.
-or ejemplo$
struct complejo j'
struct complejo Dpj J Nj'
-.G.1 Pa%o &or $a)or d# (i#(!ro% d# una #%tructura a una 3uncin
1e realiza como si fueran variables simples.
-or ejemplo, para pasar por valor el miembro a.codigo
void funcion f3,int/ CDdeclaracin la funcin prototipoDC
f3,a.codigo/' CD llamada a la funcinC
void f3,int x/ CD definicin de la funcinC
A ........
B
-.G.* Pa%o &or dir#ccin (i#(!ro% d# una #%tructura a una 3uncin
1e realiza como si fueran variables simples. -or ejemplo, para pasar por valor el miembro a.codigo
void funcion f3,int D/ CDdeclaracie la funcirototipoDC
f3,N a.codigo/' CD llamada a la funciC
void f3,int Dx/ CD definicie la funciC
A..........
..........B

-.G.- Pa%o &or $a)or d# #%tructura% co(&)#ta% a 3uncion#%.
En el siguiente ejemplo %u(a es una funcin !ue recibe dos estructuras pasadas por valor y a su vez devuelve una
estructura.
EincludeFstdio.%G
struct vector
A
int x,y,z'
B'
struct vector suma ,struct vector, struct vector/'
void main,/
A
struct vector v3,v;,v<'
v<Jsuma,v3,v;/'
B
struct vector suma,struct vector v3, struct vector v;/
A
v3.xdJv;.x'
v3.ydJv;.y'
71
v3.zdJv;.z'
return ,v3/'
B
-.G.1 Pa%o &or dir#ccin d# #%tructura% co(&)#ta% a 3uncion#%
Cuando las estructuras son muy grandes es ms eficiente pasarlas por direccin. En ese caso se utilizan punteros a
estructuras para realizar la comunicacin. -ara acceder a los miembros de la estructura debe utilizarse la combinacin
de los operadores " D " y punto , . /. 1in embargo el operador punto tiene ms precedencia !ue D si endo necesario el uso
de parntesis para asegurar !ue se apli!ue primero D y despus el punto. >ambin puede utilizarse el operador &G para
acceder a los miembros de una estructura referenciada por un puntero.
Ejemplo -aso por direccin de estructuras completas a funciones
Einclude F stdio.% G
struct pareja
A
int a,b'
B'
void f3,struct pareja D/'
void main,/
A
struct pareja p J A 3<, 35B CD inicializacie los miembrosDC
f3,N p/'
printf,"valor de a$Md valor de b$MdSn",p.a,p.b/' CD escribe 3O y 39 DC
B
void f3,struct pareja D!/
A
! & G add' CD e!uivalente a ,D!.a/dd pero musado DC
! & G bdd'
return'
B
-.H Conc#&to d# Union#%
?na unin es un tipo de datos formado por un campo capaz de almacenar un solo dato pero de diferentes tipos.
Hependiendo de las necesidades del programa el campo adoptar uno de los tipos admitidos para la unin.
-ara definir uniones C utiliza la palabra reservada unin. La definicin y el acceso al campo de la unin es anlogo al de
una estructura. 0l definir una variable de tipo unin el compilador reserva espacio para el tipo !ue mayor espacio ocupe
en la memoria. 1iempre %ay !ue tener en cuenta !ue slo se puede tener almacenado un dato a la vez en la variable.
En C es responsabilidad del programador el conocer !ueo tipo de dato se est guardando en cada momento en la unin.
-ara definir una unin seguimos la misma sintaxis !ue para las estructuras.
-or ejemplo$
union datoWnum
A
72
int num3'
float num;'
B dato'
define una unin en la !ue el campo puede ser de tipo entero o de tipo nmero con coma flotante.
Las uniones normalmente se emplean como campos en las estructuras. -ara llevar la cuenta del tipo de datos
almacenado en la unin normalmente se reserva un campo en la estructura. -or ejemplo$
struct datoWnum
A
int tipo'
unin A
float simple'
double doble'
Bdato'
B'
Las uniones son especialmente tiles para la realizacin de registros de bases de datos, ya !ue permiten almacenar
informacin de diferentes tipos dentro de los registros. En programacin de sistemas es usual encontrarlas dentro de las
estructuras de datos de las rutinas, ya !ue permiten una gran flexibilidad a la %ora de almacenar informacin.
-.I Conc#&to d# Enu(#racin
0 veces los datos se ajustan a series ordenadas en las cuales un elemento sigue, o precede, a otro. ?n caso t)pico son
los d)as de la semana. 1i se desea realizar iteraciones con los d)as de la semana una forma es, por ejemplo, asignar un
nmero a cada d)a con Edefine. C proporciona un mecanismo compacto para realizar esto' son las enumeraciones. ?na
enumeracin toma la forma$
enum nombre A lista de elementos B'.
beamos un ejemplo$
void planning , void /
A
enum diasemana A lunes, martes, miercoles, jueves, viernes, sabado, domingo B'
int dia'
for , dia J lunes' dia FJ viernes' diadd /
trabajar,dia/'
if , dia JJ sabado /
salir,/'
B
0 cada elemento de la enumeracin se le asigna un valor consecutivo, comenzando por =.
-.1R R#%u(#n
-ara la definicin de estructuras el C dispone de la palabra reservada struct. -ara crear una estructura primero
comenzamos por definir el tipo de estructura. -ara ello se procede de manera parecida a la definicin de una variable,
con algunas modificaciones.
-rimero colocamos la palabra reservada struct
luego el identificador !ue da nombre al nuevo tipo de estructura
73
Luego abrimos llaves
y comenzaremos a definir los campos de la estructura.
Cada campo se define como una variable normal, es decir, dando su tipo y un identificador, se puede incluir
cual!uier definicin de tipo %abitual, incluso punteros y estructuras.
El identificador sirve para designar a cada campo.
Cada definicin de campo acabar con un punto y coma, como siempre
finalizaremos la definicin de la estructura con una llave de cierre y un punto y coma.
La definicin de una unin es anloga a la definicin de una estructura. La diferencia entre ambas es !ue los campos
!ue especifi!uemos en una unin ocupan todos la misma posicin de memoria. Cuando se declara una unin se
reserva espacio para poder almacenar el campo de mayor tama8o de los declarados.
-.11 Auto#$a)uacin
3. Conteste las siguientes preguntas$
a/ c]u es una EstructuraK
b/ cEn !u se diferencia una estructura de un arrayK
c/ c]u es un miembroK
d/ cCul es la relacin entre un miembro y una estructuraK
e/ Hescribir la 1intaxis para definir una estructura.
f/ c-ueden ser inicializados los miembros individuales dentro de una declaracin de tipo estructuraK
g/ cCmo -ueden declararse variables de estructuraK
%/ cEn !u se diferencian las declaraciones de tipos de estructuraK
i/ c1e puede definir una variable de estructura como miembro de otra estructuraK
j/ c-uede incluirse un array como miembro de una estructuraK
[/ c-uede un array tener estructuras como elementosK
l/ cCmo se le asignan balores iniciales a los miembros de una estructuraK
m/ c]u restricciones se aplican a los tipos de almacenamiento de una estructura cuando se asignan valores
inicialesK
n/ cCmo se inicializa un array de estructuraK
o/ cCul es el mbito de un nombre de miembroK
p/ c]u implica esto con respecto al nombre de los miembros dentro de estructuras diferentesK
!/ cCmo accede a un miembro de una estructuraK
r/ cCmo se puede procesar un miembro de una estructuraK
Pro!)#(a%
3/ Hefinir una estructura !ue conste de dos miembros en coma flotante llamados r#a) e i(a'inario. Hefinir el
tipo de la estructura como co(&)#"o dentro de la definicin.
;/ Heclarar las variables S1= S* @ S- como estructuras de tipo co(&)#"o , descrita en el problema anterior.
</ Combinar la definicin y la declaracin de la estructura descritas en los -roblemas 3 y ;.
O/ Heclarar una variable S como una estructura del tipo co(&)#"o, descritas en el problema 3, asignar los valores
iniciales 1.- @ T*.* a los miembros S. R#a) y S. i(a'inario, respectivamente.
P/ Heclarar una variable puntero, &<, !ue apunte a una estructura del tipo complejo, descrita en el problema 3.
4/ Escribir expresiones para los miembros de la estructura en trminos variables puntero.
74
5/ Heclarar un array unidimensional de 1RR elementos ,llamada c<, cuyos elementos sean estructuras del tipo
co(&)#"o descritas en el problema 3.
9/ Combinar la declaracin de la estructura y la definicin del array descritas en los problemas 3y 4 en una sola
declaracin.
:/ 1upongamos !ue c< es un array unidimensional de 3== estructuras como se describe en el problema 4.
3=/ Escribir expresiones para los miembros del elemento decimoctavo de la formacin ,Elemento nmero 35/.
33/ Hefinir la estructura !ue contenga los siguientes tres miembros $
?na cantidad entera llamada 'anado%
?na cantidad entera llamada &#rdido%
?na cantidad en coma flotante llamada &orc#nta"#
.ncluir el tipo de dato definido por usuario r#'i%tro dentro de la definicin.
3;/ Hefinir una estructura !ue contenga los dos miembros siguientes$
?n arreglo de 1R caracteres llamadas no(!r#
?na estructura llamada &o%icin , del tipo r#'i%tro definido en el problema anterior.
.ncluir el tipo de dato definido por el usuario #5ui&o dentro de la definicin.
3</ Escribir un programa !ue almacene en un array los nombres y nmeros de telfono de 3= personas. El
programa debe leer los datos introducidos por el usuario y guardarlos en memoria. Hespus debe ser capaz
de buscar el nombre correspondiente a un nmero de telfono y el telfono correspondiente a una persona.
0mbas opciones deben se accesibles a travs de un men, as) como la opcin de salir del programa. El men
debe tener esta forma, ms o menos$
a/ 6uscar por nombre
b/ 6uscar por nmero de telfono
c/ 1alir
-ulsa una opcin$
Nota: #o olvides !ue para comparar cadenas se debe usar una funcin, no el operador JJ.
3O/ -ara almacenar fec%as podemos crear una estructura con tres campos$ ao, mes y d)a. Los d)as pueden tomar
valores entre 3 y <3, los meses de 3 a 3; y los a8os, dependiendo de la aplicacin, pueden re!uerir distintos
rangos de valores. -ara este ejemplo consideraremos suficientes 3;9 a8os, entre 3:4= y ;=95. En ese caso
el a8o se obtiene sumando 3:4= al valor de a8o. El a8o ;==< se almacena como O<.
?sando estructuras, y ajustando los tipos de los campos, necesitamos un c%ar para d)a, un c%ar para mes y
otro para a8o.
Escribir dos funciones ms. La primera debe responder a este prototipo$ int Comparar(ec%as,fec%a, fec%a/' Hebe
comparar las dos fec%as suministradas y devolver 3 si la primera es mayor, &3 si la segunda es mayor y = si son
iguales.
La otra funcin responder a este prototipo$ int Hiferencia,fec%a, fec%a/', y debe devolver la diferencia en d)as entre
las dos fec%as suministradas.
3P/ Hescribir la salida generada por cada uno de los siguientes programas. Explicar cual!uier diferencia entre
ellos.
Einclude Fstdio.%G
typedef struct A
c%ar D a'
c%ar Db'
75
c%ar Dc'
B colores '
void func ,colores muestra/'
main ,/
A
static colores muestra J A IrojoL , I verde I, IazulLB'
printf , IMs MsSn , muestra. a,muestra.b , muestra.c /'
func ,muestra /'
printf , IMs Ms MsSnL ,muestra.a ,muestra .b , muestra. c/'
B
void func ,colores muestra/
A
muestra . a J IcianL '
muestra . b J ImagentaL'
muestra . c J Iamarillo I
printf , I Ms Ms Ms Sn I , muestra . a, muestra . b, muestra . c /'
return '
B
E include Fstdio.%G
typedef struct A
c%ar Da'
c%ar Db'
c%ar Dc'
B colores '
void fun. ,colores Dpt /'
main , /
A
static colores muestra J A Irojo I, Iverde I, I azulL B'
printf , I Ms Ms M s Sn I, muestra . a ,muestra . b , muestra. C/ '
func , N muestra / '
printf , I Ms Ms MsSn I, muestra . a , muesta . b , muestra . c/'
B
void func ,colores Dpt/
A
pt&G a J Iclain I '
pt&G b J Imagenta I '
pt&Gc J IamarilloL '
printf , IMs Ms MsSn I, pt Ga, pt &Gb, pt&Gc/'
B
E include Fstdio.% G
76
typedef struct A
c%ar D a'
c%ar D b'
c%ar Dc'
B colores '
colores func ,colores muestral /'
main , /
A
static colores muestral J ,Irojo I , I verde I, I azulL / B '
printf , IMs Ms MsSn I, muestra . a , muestra . b , muestra . c /'
muestra J func ,muestra / '
printf ,I Ms Ms MsSn I, muestra . a , muestra . b, muestra . c / '
B
colores func ,colores muestra /
A
muestra . a J Ician I'
muestra . b J I magenta I
muestra . c J I amarillo I
print f , I M s Ms MsSnL, muestra .a , muestra . b, muestra . c/ '
return ,muestra/ '
B
77
$nidad %%%& <unteros
1.1 Conc#&to d# Punt#ro%
Hentro de la memoria de la computadora cada dato almacenado ocupa una o ms celdas contiguas de memoria. El
nmero de celdas de memoria re!ueridas para almacenar un dato depende de su tipo. 1i $ es una variable !ue
representa un determinado dato, el compilador automticamente asigna celdas de memoria para ese dato. El dato
puede ser accedido si conocemos su localizacin ,la direccin/ de la primera celda de memoria.
Los punteros en el Lenguaje C, son variables !ue " apuntan ", es decir !ue poseen la direccin de las ubicaciones en
memoria de otras variables, y por medio de ellos se tiene un poderoso mtodo de acceso a todas ellas.
Los operadores monarios U y / son miembros del mismo grupo de precedencia !ue los otros operadores monarios$ ;,V
V,;;=W,%iF#o3 y ,ti&o/. *ay !ue recordar !ue este grupo de operadores tiene mayor precedencia !ue el de los operadores
aritmticos y la asociatividad de los operadores monarios es de derec%a a iz!uierda.
El operador direccin ,U/ slo puede actuar sobre variables ordinarias o elementos simples de un array.
El operador indireccin 9// slo puede actuar sobre operandos !ue sean punteros.
Las variables puntero pueden apuntar a variables numricas o de caracteres, arreglos, funciones u otras variables
puntero. ,>ambin pueden apuntar a otros tipos de estructuras de datos !ue se vern posteriormente/.
-or tanto a una variable puntero se le puede asignar la direccin de una variable ordinaria. >ambin se le puede asignar
la direccin de otra variable puntero, siempre !ue ambas apunten al mismo tipo de dato.
1.* D#c)aracin d# Punt#ro%
Los punteros, como cual!uier otra variable, deben ser declarados antes de ser usados. Cuando una variable puntero es
definida, el nombre de la variable debe ir precedida por un asterisco 9/:. Este identifica !ue la variable es un puntero.
El tipo de dato !ue aparece en la declaracin se refiere al tipo de objeto del puntero, el tipo de dato !ue se almacena en
la direccin representada por el puntero, en vez del puntero mismo. 0s), una declaracin de puntero general es$
tipo#dato /ptvarL
donde
ptvar es la variable puntero y
tipo_dato el tipo de dato apuntado por el puntero.
Hentro de la declaracin, una variable puntero puede ser inicializada asignndole la direccin de otra variable ,sta debe
estar previamente declarada/.
beamos primero, como se declara un puntero$
tipo de variable apuntada DnombreWdelWpuntero '
int Dpint '
double Dpfloat '
c%ar Dletra , Dcodigo , Dcaracter '
78
En estas declaraciones slo decimos al compilador !ue reserve una posicin de memoria para albergar la direccin de
una variable, del tipo indicado , la cual ser referenciada con el nombre !ue %ayamos dado al puntero.
2bviamente, un puntero debe ser inicializado antes de usarse, y una de las formas ms comunes de %acerlo es la
siguiente$
int var3 ' CD declara , y crea en memoria / una variable entera / DC
int Dpint ' CD " " " " " un puntero !ue contendr la direccin de una
variable entera DC
pint J Nvar3 ' CD escribe en la direccin de memoria donde est el puntero la
direccin de la variable entera DC
1.- Punt#ro% @ Arr#')o%
*ay una estrec%a relacin entre los punteros y los arreglos. El nombre de un arreglo es e!uivalente a la direccin del
elemento V=Y del mismo. El nombre de un arreglo, para el compilador de C= es un -?#>E72 inicializado con la direccin
del primer elemento del arreglo. 1in embargo %ay una importante diferencia entre ambos.

beamos algunas operaciones permitidas entre punteros$
A%i'nacin
float var3 , conjuntoVY J A :.= , 9.= , 5.= , 4.= , P.= /'
float Dpunt '
punt J conjunto ' CD e!uivalente a %acer $ punt J Nconjunto V=Y DC
var3 J Dpunt '
Dpunt J ;P.3 '
Es perfectamente vlido asignar a un puntero el valor de otro, el resultado de sta operacin es cargar en el puntero punt
la direccin del elemento V=Y del arreglo conjunto, y posteriormente en la variable var3 el valor del mismo ,:.=/ y para
luego cambiar el valor de dic%o primer elemento a ;P.3

beamos cual es la diferencia entre un puntero y el nombre de un arreglo$ el primero es una b07.06LE, es decir !ue se
puede asignarle un valor, incrementarla etc, en cambio el segundo es una C2#1>0#>E, !ue apunta siempre al primer
elemento del arreglo con !ue fue declarado, por lo !ue su contenido #2 -?EHE 1E7 b07.0H2.
1i lo piensa un poco, es lgico, ya !ue "conjunto" implica la direccin del elemento conjunto V=Y, por lo !ue, si yo
cambiara su valor, apuntar)a a otro lado dejando de ser, "conjunto". Hesde este punto de vista, el siguiente ejemplo nos
muestra un tipo de error bastante frecuente$
ASICNACION ERRONEA
int conjuntoVPY , listaVY J A P , 4 , 5 , 9 , = / '
int Dapuntador '
79
apuntador J lista ' CD correcto DC
conjunto J apuntador' CD E7727 , se re!uiere en Lvalue no constante / DC
lista J conjunto ' CD E7727 , idem / DC
apuntador J Nconjunto CD E7727 no se puede aplicar el operador N ,direccin/ a
una constante DC
1.1 Pa%o d# Punt#ro% a una Buncin
Con muc%a frecuencia los punteros son pasados a las funciones como argumentos. Esto permite !ue datos de la porcin de
programa desde el !ue se llama a la funcin sean accedidos por la funcin, alterados dentro de ella y devueltos de forma
alterada. Este uso de los punteros se conoce como paso, de ar"umentos por direccin o referencia.
Cuando los punteros son usados como argumento de una funcin, es necesario tener cuidado con la declaracin de los
argumentos formales dentro de la funcin. Los argumentos formales !ue sean punteros deben ir precedidos por un
asterisco.
Ejemplo$
EincludeFstdio.%G
void f3,int,int/'
void f;,int D,int D/'
void main,/
A
int uJ3,vJ<'
f3,u,v/'
printf,"despus de la llamada a f3$ uJMd vJMdSn",u,v/'
f;,Nu,Nv/'
printf,"despus de la llamada a f;$ uJMd vJMdSn",u,v/'
B
void f3,int u,int v/
A
uJ='
vJ='
B
void f;,int Dpu,int Dpv/
A
DpuJ='
DpvJ='
B
La salida del programa$
despus de la llamada a f3$ uJ3 vJ<
despus de la llamada a f;$ uJ= vJ=
80
1.4 Arit(Dtica d# Punt#ro%
1e domina !ue a un valor entero se le puede sumar al nombre de un arreglo para acceder a uno de sus elementos. El
valor entero es interpretado como el )ndice del arreglo' representa la localizacin relativa del elemento deseado con
respecto al primero. Esto funciona por!ue todos los elementos del arreglo son del mismo tipo y por tanto cada elemento
ocupa un mismo nmero de celdas de memoria. El nmero de celdas !ue separan a dos elementos del array
depender del tipo de datos del array, pero de esto se encarga el compilador automticamente.
Este concepto se puede extender a variables puntero. En particular, un valor entero puede ser sumado o restado a una
variable puntero, pero el resultado de la operacin debe ser interpretado con cuidado.
1upongamos !ue &< es una variable puntero !ue representa la direccin de una variable <. 1e pueden escribir
expresiones como
ddpx'
&&px'
,pxd</.
Cada expresin representa una direccin localizada a cierta distancia de la posicin original representada por px.
La distancia exacta ser el producto de la cantidad entera por el nmero de bytes !ue ocupa cada elemento al !ue
apunta px.
1.4.1 R#%u(#n d# o&#racion#% 5u# %# &u#d#n r#a)iFar %o!r# &unt#ro%:
3. 0 una variable puntero se le puede asignar la direccin de una variable ordinaria ,pvJNv/.
;. 0 una variable puntero se le puede asignar el valor de otra variable puntero, siempre !ue ambas apunten al mismo
tipo de dato.
<. 0 una variable puntero se le puede asignar el valor nulo ,#?LL/.
O. ?na cantidad entera puede ser sumada o restada a una variable puntero.
P. ?na variable puntero puede ser restada de otra con tal de !ue ambas apunten a elementos del mismo arreglo.
4.
Hos variable puntero pueden ser comparadas siempre !ue ambas apunten a datos del mismo tipo.
5.
#o se permiten operaciones aritmticas con punteros. 0s) una variable puntero no puede ser multiplicada por una
constante, dos punteros no pueden sumarse, etc.
La aritmtica ms frecuentemente usada con punteros son las sencillas operaciones de asignacin, incremento
decremento y dereferenciacin. >odo otro tipo de aritmtica con ellos est pro%ibida es de uso peligroso poco
transportable.
-or ejemplo no est permitido, sumar, restar, dividi, multiplicar etc., dos apuntadores entre s). Lo cual si lo pensamos un
poco es bastante lgico, ya !ue de nada me servir)a sumar dos direcciones de memoria.
2tras operaciones estn permitidas , como la comparacin de dos punteros , por ejemplo , punt3 JJ punt; / , punt3 F
punt; / sin embargo este tipo de operaciones son potencialmente peligrosas, ya !ue con algunos modelos de punteros
pueden funcionar correctamente y con otros no .
81
1.7 Arr#')o d# Punt#ro%
Es una prctica muy %abitual, sobre todo cuando se tiene !ue tratar con strings de distinta longitud, generar arreglos
cuyos elementos son punteros , !ue albergarn las direcciones de dic%os strings.

0s) como$
c%ar Dflec%a'
defin)a a un puntero a un carcter, la definicin
c%ar DcarcaVPY'
implica un arreglo de P punteros a caracteres .
?n arreglo multidimensional puede ser expresado como un arreglo de punteros en vez de como un puntero a un grupo
contiguo de arreglos.
En trminos generales un arreglo bidimensional puede ser definido como un arreglo unidimensional de punteros escribiendo
tipo#dato =nom#arra>(expresin1*
en lugar de
tipo#dato nom#arra>(expresin1*(expresin2*
#otar !ue el nombre del arreglo precedido por un asterisco no est cerrado entre parntesis. 1e asocia primero el par de
corc%etes con nomWarray definindolo como un arreglo. El asterisco !ue lo precede establece !ue el arreglo contendr
punteros.
E"#(&)o:
1uponer !ue < es un arreglo bidimensional de 3= filas y ;= columnas. 1e puede definir < como un arreglo unidimensional
de punteros escribiendo
int /<J1RKL
0!u) <V=Y apunta al primer elemento de la primera fila, xV3Y al primer elemento de la segunda fila, y as) sucesivamente.
#otar !ue el nmero de elementos dentro de cada fila no est especificado expl)citamente.
?n elemento individual del arreglo, tal comomo
<J*KJ4K puede ser accedido escribiendo /9<J*KV4:
En esta expresin <J*K es un puntero al primer elemento en la fila ;, de modo !ue
,xV;YdP/ apunta al elemento P de la fila ;.
El objeto de este puntero, D,xV;YdP/, refiere, por tanto, a xV;YVPY.
Los arreglos de punteros ofrecen un mtodo conveniente para almacenar cadenas.
En esta situacin cada elemento del arreglo es un puntero !ue indica dnde empieza cada cadena.
82
1.G R#%u(#n
?n puntero es un tipo especial de variable, !ue almacena el valor de una dir#ccin d# (#(oria, esta direccin puede
ser la de una variable individual, pero ms frecuentemente ser la de un elemento de un arreglo, una estructura u objeto
de una clase.
Los punteros, al igual !ue una variable comn, pertenecen a un tipo ,type/, se dice !ue un puntero j a&unta aj ese tipo al
!ue pertenece.
Ejemplos$
intD pint CCHeclara un puntero a entero
c%arD pc%ar CC-untero a c%ar
fec%aD pfec%a CC-untero a objeto de clase jfec%aj
.ndependientemente del tama8o ,sizeof/ del objeto apuntado, el valor almacenado por el puntero ser el de una nica
direccin de memoria. En sentido estricto un puntero no puede almacenar la direccin de memoria de jun arreglog
,completo/, sino la de un elemento de un arreglo, y por este motivo no existen diferencias sintcticas entre punteros a
elementos individuales y punteros a arreglo.
La declaracin de un puntero a char y otro a arreglo de char es igual.
?n puntero, como cual!uier variable u objeto, adems de ser d#c)arado ,para comenzar a existir/ necesita ser
inicia)iFado ,darle un valor de modo controlado/, lo cual se realiza mediante el operador de asignacion ,jJj/. Hesde !ue
el puntero es declarado almacena un valor, el problema es !ue se trata de un valor aleatorio, intentar operar con un
puntero sin %aberlo inicializado es una frecuente causa de problemas.
?n puntero puede ser inicializado con la direccin de memoria de un objeto, tal objeto debe pertenecer a un tipo acorde
al tipo al !ue apunta el puntero. -uede tratarse de la direccin de un elemento de un arreglo o de una variable individual,
el operador jNj antepuesto a un objeto nos devuelve su direccin de memoria.
>ambin puede utilizarse un "literal", ya sea numrico, de carcter, o de otro tipo, y puede inicializarse como puntero
nulo, en este caso esta permitido usar el =, el nico entero permitido, por su e!uivalencia con el valor #?LL.
83
1.H Auto#$a)uacin
3. Hado el programa siguiente, ca dnde apunta [3K
main,/
A
int ['
int D[3'
B
;. Hado el programa siguiente, ca dnde apunta m3K
int Dm3'
main,/
A
h..
B
<. Conteste las siguientes preguntas$
a/ cCunto espacio de almacenamiento ocupa un arreglo de diez enterosK
b/ cCunto espacio de almacenamiento ocupa un puntero a enteroK
O. Heclarar longs llamados a, b y c, y punteros a long llamados p, ! y r' y dar las sentencias en C para realizar las
operaciones siguientes.
-ara cada caso, es!uematizar el estado final de la memoria.
Cargar p con la direccin de a. 1i a%ora escribimos Dp J 3===, c!u ocurreK
Cargar r con el contenido de p. 1i a%ora escribimos Dr J 3===, c!u ocurreK
Cargar ! con la direccin de b, y usar ! para almacenar una constante OL en el espacio de b
Cargar en c la suma de a y b, pero sin escribir la expresin "adb"
0lmacenar en c la suma de a y b pero %aciendo todos los accesos a las variables en forma indirecta
P. Compilar y ejecutar$
main,/
A
c%ar Da J "Ejemplo"'
printf,"MsSn",a/'
B
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
main,/
A
c%ar Da'
printf,"MsSn",a/'
B
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
main,/
A
c%ar Da J "Ejemplo"'
84
c%ar Dp'
p J a'
printf,"MsSn", p/'
B
4. c]u imprimirn estas sentenciasK
c%ar Ds J "06CHE(`"'
printf,"MsSn", s/'
printf,"MsSn", s d =/'
printf,"MsSn", s d 3/'
printf,"MsSn", s d 4/'
printf,"MsSn", s d 5/'
printf,"MsSn", s d 9/'
5. c1on correctas estas sentenciasK 6os!ueje un diagrama del estado final de la memoria para a!uellas !ue lo sean.
a/ c%ar Da J "?no"'
b/ c%ar Da, b' a J "?no"' b J "Hos"'
c/ c%ar Da,Db ' a J "?no"' b J a'
d/ c%ar Da,Db ' a J "?no"' b J Da'
e/ c%ar Da,Db ' a J "?no"' Db J a'
f/ c%ar Da J "Hos"' Da J j>j'
g/ c%ar Da J "Hos"' a J ">"'
%/ c%ar Da J "Hos"' D,a d 3/ J jij' D,a d ;/ J jaj'
i/ c%ar Da, Db ' b J a'
9. Escribir funciones para$
Calcular la longitud de una cadena.
Hado un carcter determinado y una cadena, devolver la primera posicin de la cadena en la !ue se lo
encuentre, o bien &3 si no se %alla.
Comparar dos cadenas, devolviendo = si son iguales, un valor negativo si la primera es lexicogrficamente
menor, un valor positivo si es mayor.
.dem pero comparando %asta el n&simo carcter y con las mismas convenciones de salida.
.dem pero ignorando las diferencias entre maysculas y minsculas.
85
6uscar una subcadena en otra, devolviendo un puntero a la posicin donde se la %alle.
86
LECTURAS ADICIONALES
Dato%
CONTENIDO
1. E) Conc#&to d# Dato%
*. E) Conc#&to d# In3or(acin
-. Di3#r#ncia #ntr# Dato% # in3or(acin
1. E) Conc#&to d# Proc#%a(i#nto d# Dato%
4. Conc)u%in
1. E) Conc#&to d# Dato%
Hatos son los %ec%os !ue describen sucesos y entidades."Hatos" es una palabra en plural !ue se refiere a ms de un
%ec%o. 0 un %ec%o simple se le denomina "data&)tem" o elemento de dato. Los datos son comunicados por varios tipos
de s)mbolos tales como las letras del alfabeto, nmeros, movimientos de labios, puntos y rayas, se8ales con la mano,
dibujos, etc. Estos s)mbolos se pueden ordenar y reordenar de forma utilizable y se les denomina informacin.
Los datos son s)mbolos !ue describen condiciones, %ec%os, situaciones o valores. Los datos se caracterizan por no
contener ninguna informacin. ?n dato puede significar un nmero, una letra, un signo ortogrfico o cual!uier s)mbolo
!ue represente una cantidad, una medida, una palabra o una descripcin. La importancia de los datos est en su
capacidad de asociarse dentro de un contexto para convertirse en informacin. -or si mismos los datos no tienen
capacidad de comunicar un significado y por tanto no pueden afectar el comportamiento de !uien los recibe. -ara ser
tiles, los datos deben convertirse en informacin para ofrecer un significado, conocimiento, ideas o conclusiones.
*. E) Conc#&to d# In3or(acin
La informacin no es un dato conjunto cual!uiera de ellos. Es ms bien una coleccin de %ec%os significativos y
pertinentes, para el organismo u organizacin !ue los percibe. La definicin de informacin es la siguiente$ .nformacin
es un conjunto de datos significativos y pertinentes !ue describan sucesos o entidades. H0>21 1.`#.(.C0>.b21. -ara
ser significativos, los datos deben constar de s)mbolos reconocibles, estar completos y expresar una idea no ambigua.
Los s)mbolos de los datos son reconocibles cuando pueden ser correctamente interpretados. \uc%os tipos diferentes de
s)mbolos comprensibles se usan para transmitir datos. La integridad significa !ue todos los datos re!ueridos para
responder a una pregunta espec)fica estn disponibles. -or ejemplo, un marcador de bisbol debe incluir el tanteo de
ambos e!uipos. 1i se oye el tanteo "#e+ eor[ 4" y no oyes el del oponente, el anuncio ser incompleto y sin sentido.
Los datos son ine!u)vocos cuando el contexto es claro. -or ejemplo, el grupo de signos ;&x puede parecer "la cantidad ;
menos la cantidad desconocida llamada x" para un estudiante de lgebra, pero puede significar "; barra x" a un va!uero
!ue marca ganado. >enemos !ue conocer el contexto de estos s)mbolos antes de poder conocer su significado. 2tro
ejemplo de la necesidad del contexto es el uso de trminos especiales en diferentes campos especializados, tales como
la contabilidad. Los contables utilizan muc%os trminos de forma diferente al pblico en general, y una parte de un
aprendizaje de contabilidad es aprender el lenguaje de contabilidad. 0s) los trminos Hebe y *aber pueden significar
para un contable no ms !ue "derec%a" e "iz!uierda" en una contabilidad en >, pero pueden sugerir muc%os tipos de
ideas diferentes a los no contables. H0>21 -E7>.#E#>E1. Hecimos !ue tenemos datos pertinentes ,relevantes/
cuando pueden ser utilizados para responder a preguntas propuestas. Hisponemos de un considerable nmero de
%ec%os en nuestro entorno. 1olo los %ec%os relacionados con las necesidades de informacin son pertinentes. 0s) la
organizacin selecciona %ec%os entre sucesos y entidades particulares para satisfacer sus necesidades de informacin.
-. Di3#r#ncia #ntr# Dato% # in3or(acin
87
3. Los Hatos a diferencia de la informacin son utilizados como diversos mtodos para comprimir la informacin a
fin de permitir una transmisin o almacenamiento ms eficaces.
;. 0un!ue para el procesador de la computadora %ace una distincin vital entre la informacin entre los
programas y los datos, la memoria y muc%as otras partes de la computadora no lo %ace. 0mbos son
registradas temporalmente segn la instruccin !ue se le de. Es como un pedazo de papel no sabe ni le
importa lo !ue se le escriba$ un poema de amor, las cuentas del banco o instrucciones para un amigo. Es lo
mismo !ue la memoria de la computadora. 1lo el procesador reconoce la diferencia entre datos e informacin
de cual!uier programa. -ara la memoria de la computadora, y tambin para los dispositivos de entrada y salida
,EC1/ y almacenamiento en disco, un programa es solamente ms datos, ms informacin !ue debe ser
almacenada, movida o manipulada.
<. La cantidad de informacin de un mensaje puede ser entendida como el nmero de s)mbolos posibles !ue
representan el mensaje."los s)mbolos !ue representan el mensaje no son ms !ue datos significativos.
O. En su concepto ms elemental, la informacin es un mensaje con un contenido determinado emitido por una
persona %acia otra y, como tal, representa un papel primordial en el proceso de la comunicacin, a la vez !ue
posee una evidente funcin social. 0 diferencia de los datos, la informacin tiene significado para !uien la
recibe, por eso, los seres %umanos siempre %an tenido la necesidad de cambiar entre s) informacin !ue luego
transforman en acciones. "La informacin es, entonces, conocimientos basados en los datos a los cuales,
mediante un procesamiento, se les %a dado significado, propsito y utilidad"
1. E) Conc#&to d# Proc#%a(i#nto d# Dato%
*asta el momento %emos supuesto !ue los datos !ue maneja una aplicacin no son tan voluminosos y por lo tanto
caben en memoria. Cuando recurrimos a arc%ivos se debe a la necesidad de conservar datos despus de !ue termina
un programa, por ejemplo para apagar el computador. 1in embargo, existen problemas en donde el volumen de datos
es tan grande !ue es imposible mantenerlos en memoria. Entonces, los datos se almacenan en un conjunto de arc%ivos,
los !ue forman una base de datos. ?na base de datos es por lo tanto un conjunto de arc%ivos !ue almacenan, por
ejemplo, datos con respecto al negocio de una empresa. Cada arc%ivo se forma en base a un conjunto de l)neas y cada
l)nea esta formada por campos de informacin. >odas las l)neas de un mismo arc%ivo tienen la misma estructura, es
decir los mismos campos de informacin. Hiferentes arc%ivos poseen estructuras distintas, i.e. campos de informacin.
-or ejemplo, el arc%ivo de postulantes post.dat, visto en cap)tulos anteriores, tiene la siguiente informacin$
ci$ carnet de identidad de la persona.
nombre.
En lo !ue sigue supondremos !ue ambos arc%ivos son lo suficientemente grandes como para !ue no !uepan en la
memoria del computador. 0 continuacin resolveremos eficientemente el problema de generar un arc%ivo con los tres
campos de informacin, sin colocar previamente el contenido de un arc%ivo en un arreglo.
0lgunas definiciones 7ecoleccin de datos$ -rovee un v)nculo para obtener la informacin interoperacionables
racional y las parametrizaciones. 0lmacenamiento de datos$ Las unidades de disco de la computadora y otros medios
de almacenamiento externo permiten almacenar los datos a ms largo plazo, mantenindolos disponibles pero
separados del circuito principal %asta !ue el microprocesador los necesita. ?na computadora dispone tambin de otros
tipos de almacenamiento.
La memoria de slo lectura ,72\/ es un medio permanente de almacenamiento de informacin bsica, como las
instrucciones de inicio y los procedimientos de entradaCsalida. 0simismo, una computadora utiliza varios buffers ,reas
reservadas de la memoria/ como zonas de almacenamiento temporal de informacin espec)fica, como por ejemplo los
caracteres a enviar a la impresora o los caracteres le)dos desde el teclado.
Proc#%a(i#nto d# dato%:
88
a. El objetivo es graficar el -rocesamiento de Hatos, elaborando un Hiagrama !ue permita identificar las
Entradas, 0rc%ivos, -rogramas y 1alidas de cada uno de los -rocesos.
b. 1u antecedente es el Hiagrama de (lujo.
c. Los elementos claves son los -rogramas.
d. 1e confecciona el Hiagrama de -rocesamiento de Hatos
e. Este Hiagrama no se podr elaborar por completo desde un primer momento ya !ue depende del (lujo de
.nformacin.
f. En este primer paso slo se identifican las 1alidas y -rogramas. Los elementos restantes se identifican en
forma genrica.
Va)idacin d# dato%:
Consiste en asegurar la veracidad e integridad de los datos !ue ingresan a un arc%ivo. Existen numerosas tcnicas de
validacin tales como$ Higito verificador, c%e!ueo de tipo, c%e!ueo de rango.
4. Conc)u%in
La tecnolog)a de informacin est transformando las actividades econmicas y cotidianas como uno de los fenmenos
sociolgicos ms importantes del siglo. -or esta razn, los niveles de oportunidades de trabajo se incrementan de una
manera acelerada en diferentes reas del conocimiento.
.ndiscutiblemente, las computadoras %an invadido ya todos y cada uno de los campos de la actividad %umana$ ciencia,
tecnolog)a, arte, educacin, recreacin, administracin, econom)a y de acuerdo a la tendencia actual, nuestra civilizacin
y las venideras dependern cada vez ms de estos "cerebros" electrnicos. 1e %a venido acelerando la velocidad de
cambio del medio de casi todas las organizaciones, de all) !ue stas necesiten a%ora ms informacin como soporte a la
toma de decisiones. 0un!ue las entidades de tipo educativo se %an descuidado en este aspecto, en estos momentos se
percibe un cierto inters en la implantacin de estrategias !ue logren interesar a estudiantes y profesores en el
aprendizaje de tcnicas !ue pretende a corto plazo masificar e implementar el uso de bases de datos, redes de datos e
informacin y tecnolog)a informtica de punta como %erramientas bsicas de los actuales y nuevos profesionales del
pa)s. -ara responder a los retos planteados por la nueva situacin econmica y tecnolgica mundial, se impulsa una
dinmica tendiente a dar a conocer los elementos necesarios para estar a la vanguardia en este campo.
89
CONSEJOS UTILES
0 continuacin se muestran una serie de consejos para %acer !ue el cdigo de tus aplicaciones sea ms claro, mejor y
facilite la reutilizacin$
3. Har un nombre representativo a las variables y dems elementos de la aplicacin. 1e trata de !ue al ver el
nombre sepamos !u alamacena.
Por #"#(&)o: si una variable guarda el valor total de una operacin, llamarla "Tota)" y no "$ar1", !ue no nos dice
nada acerca de su contenido.
Esto mismo es aplicable a los formularios, botones, cajas de texto ...
;. Cdigo 7epetido
1i vemos !ue en nuestra aplicacin %ay cdigo !ue se repite muc%o, lo mejor ser ponerlo dentro de un
procedimiento o de una funcin para facilitar su uso y %acer el cdigo ms inteligible.
<. Comentar El Cdigo
-oner comentarios en el cdigo. Esto facilitar muc%o el entendimiento del cdigo, el saber por!u se %a %ec%o
una determinada accin. 0dems, nos ser til para la reutilizacin del cdigo en otras aplicaciones. >ambin nos
ser de utilidad cuando dejamos de trabajar en el cdigo una temporada y al volver sobre l nos ser ms fcil
entenderlo de nuevo.
O. ?sar Constantes
?sar Constantes para valores !ue se vayan a usar muc%o en el cdigo.
-or ejemplo$ 1i vamos a usar constantemente el nmero -., en vez de estar continuamente escribiendo <.3O3P:,
declaramos lo siguiente$
>otal J 4 D -.
P. 1i al compilar tu programa el compilador te devuelve en la pantalla una lista de varios errores, dir)gete al
primero de ellos y solo al primero. Lelo con atencin. 7esulvelo y despus comprobars !ue muc%os de los
errores posteriores estaban provocados por ese primer error. #unca empieces a corregir errores por el ltimo.
4. Cuando un compilador te lance un error, antes de irte a la l)nea correspondiente del cdigo fuente, lee con
atencin la frase !ue el compilador te lanza. -ronto te familiarizars con estas frases y resolvers estos errores
muy rpidamente.
5. 1i al ejecutar tu programa ste aborta su ejecucin de forma inesperada. 0ntes de desesperarte y darte por
vencido' antes de preguntar a otra persona, !ue probablemente de tu programa sabe menos !ue tu !ue lo
ests %aciendo' antes de eso debes saber en !u l)nea de tu cdigo se interrumpe la ejecucin del programa
,para esto te ayudar meter salidas a pantalla de depuracin/. Cuando sepas la l)nea, analiza la situacin justo
en el momento de interrumpirse el programa ,para esto mete salidas de depuracin con valores de variables,
etc. y comprueba !ue esos valores son los esperados/. Hespus de %acer esto, vers como en la mayor)a de
los casos t mismo eres capaz de dar con la solucin al problema. e lo !ue es ms importante, %abrs
90
ad!uirido ms experiencia como programador ,cosa !ue no %aces si preguntas a otra persona/. 1ers poco a
poco mejor programador.
9. 2jo, una cosa es aprender de la experiencia propia programando ,!ue es de lo !ue trata el apartado anterior/ y
otra distinta aprender conceptos, tcnicas, fundamentos, etc. Cual!uier duda !ue tengas en relacin a una
tcnica, teor)a, truco, mtodo, fundamento, etc. pregntala al profesor ,por elemental y tonta !ue te parezca/.
Este es el momento. -or!ue precisamente para eso ests en la universidad, para aprender, para formarte. 1i
no lo %aces ests perdiendo una oportunidad de oro !ue no vas tener despus, y tambin va a ser dif)cil !ue la
encuentres en otro lugar. 0s) !ue, cuando no sepas una cosa$ pregntala al profesor.
:. -rograma en casa. .ntenta montar las prcticas de las asignaturas en tu casa. *oy d)a existe soft+are gratuito
y comercial suficiente y ase!uible para cual!uiera ,si no sabes como obtenerlo, pregunta a tu profesor sobre
esto/. Hebes montar y probar todo el soft+are !ue puedas en tu casa, en tu ordenador, para poder dedicar el
tiempo !ue desees a la programacin. El tiempo de prcticas en el aula con el profesor no es suficiente para
ad!uirir la experiencia suficiente para ser un programador con cierto nivel. Hebes programar y programar,
muc%)simo ms de lo !ue lo %aces en el laboratorio de prcticas, si !uieres ser un programador de cierto nivel.
.nstala aplicaciones, %erramientas de programacin de todo tipo, y anal)zalas, y "cac%arrea" con ellas. Esto es
fundamental para un informtico. -roponte tu mismo ejercicios, programas de todo tipo, etc. 0prenders
muc%)simo ms !ue de ninguna otra forma. Esto es independiente de las prcticas de las asignaturas. -ara
aprender a programar, no %ay otra forma !ue no sea programando muc%o.
3=. !ns"#ame tu cdigo$. Esta frase deber)amos dec)rsela cual!uier programador para ver !u nivel tiene, para
ver !u es lo !ue %a %ec%o todo este tiempo. El programador nos ense8ar)a entonces sus desarrollos a modo
de curr)culum. >odo programador !ue se precie debe %aber desarrollado un conjunto de programas, de
aplicaciones, de rutinas, de bibliotecas de programas, de sistemas informticos, de proyectos, de pginas +eb,
etc. c#unca le %as %ec%o un programa a tu %ermana, a tu padre, a tu primo o a un vecinoK. 0un!ue sean de
prueba, o ejemplos !ue nunca se %ayan utilizado, o juegos. Hebemos recopilarlos y mantenerlos, y usarlos
como carta de presentacin llegado el caso. -onte a %acerlos a%ora mismo, en tus ratos libres. 1i no tienes,
bscalos, propntelos como ejercicio y, !uien sabe, !uizs incluso surjan buenas ideas y lleguen a ser
aplicaciones importantes algn d)a. En el peor caso servirn para !ue ad!uieras una experiencia muy valiosa,
e incrementarn tu curr)culum. Ens8aselas a tus amigos, a tus profesores, en entrevistas de trabajo si al caso,
%az una pgina +eb y descr)belas, etc. be mantenindolas poco a poco, depurndolas y mejorndolas con el
tiempo. >rabaja tambin si puedes en e!uipo con tus amigos, participa en proyectos de desarrollo. *ay miles,
busca uno !ue te guste, contribuye, aprende.
33. (recuenta revistas de informtica, foros en .nternet, portales de noticias especializadas' comun)cate con otros
informticos y mantente informado de todo. En este campo nuestro, el cambio y evolucionar con l, por suerte
o por desgracia, es una constante.
3;. \ientras estas estudiando aprende distintas tcnicas y metodolog)as para !ue te formes como un buen
programador, y ejercita todas ellas para ad!uirir pericia utilizndoles. 1i no, cen !u te diferencias de todos
esos !ue sin formacin ni experiencia dicen !ue saben programarK, !ue %ay miles.....
3<. ]uizas sepas manejar pocas %erramientas. ]uizs no %ayas tenido tiempo de manejar muc%as utilidades,
programas, lenguajes. -ero las %erramientas, programas, lenguajes, etc., !ue normalmente uses dom)nalos
por completo. Conoce bien y ejercita todas sus posibilidades. 0prndete de memoria los comandos, las
instrucciones, las funciones, los detalles para su correcta utilizacin. Hefiendete a la perfeccin %ablando de
ellos, !ue se note !ue los dominas y !ue sabes como usarlas en todo su potencial. >u nivel con esas
%erramientas es una prueba clara de %asta donde puedes llegar con otras %erramientas, y el !ue te entreviste y
te evale te distinguir rpidamente del c%arlatn, del !ue dice saber manejar muc%as %erramientas, lenguajes,
etc. pero no tiene un conocimiento profundo de ninguna de ellas, con lo cual no puede utilizarlas sino es de
forma mediocre, o peor an, no puede utilizarlas de ninguna forma.
91
3O. 0prende .ngls$ debes %ablar, y por supuesto, leer y escribir ingls a un alto nivel.
3P. \uc%os alumnos a lo largo de su carrera deben dirigirse a profesores mediante e&mail. 0un!ue esto parezca
algo sencillo, por mi propia experiencia y la de algunos compa8eros puedo decir !ue muc%os alumnos no
saben como escribir un e&mail y lo %acen de forma inadecuada, saltndose muc%as veces las ms bsicas
normas de escritura y de forma !ue deben guardar estos documentos. 0dems, ser frecuente !ue un alumno
escriba muc%os e&mails, no ya solo a profesores, sino a otros profesionales, a compa8eros, a otros
programadores dentro y fuera de su ciudad, a empresas, etc. Cuando dirijas un e&mail a alguien !ue no te
conoce debes dejarle claro !uien eres, y tu propia direccin de correo electrnico no basta. En el caso de un
profesor debes decirle$ tu nombre, titulacin, especialidad y asignatura ,lgicamente, si ests conversando con
l y os enviis varios e&mails no es necesario !ue le repitas esto cada vez/. Hebes poner un saludo al inicio
del e&mail, y una despedida al final del e&mail despus de la cual ir tu nombre y !uizs otros datos como la
direccin, etc.. Esto es por cortes)a y educacin, y se suele %acer en la confeccin de cual!uier escrito, carta,
etc. Cuida la redaccin, las faltas de ortograf)a, las expresiones !ue utilizas, la estructura en prrafos, el
orden. ,*e recibido ya algunos e&mails de alumnos incluso con frases y expresiones de esas "abreviadas"
como si estuvieran enviando un mensaje a un mvil o incluso c%ateando./
92