Guia Teorica Programacion II

Docentes Colaboradores
Recopilado por: Docentes del rea de Programacin / Trayecto I / Trimestre II

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina

Lcdo. Rubn Cova Lcdo. Luis Rigual

Lcda. Gladimar Serrano Lcda. Nakary Ortega. MSc

Ing. Leonardo Malav. MSc Lcdo. Franklin Mundaray

Lcda. Lisblein rismendi !S" Rodol#o Ort$%

Lcdo. &dinson Gon%'le%
!ndice

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina "

('gina
Objetivo 1.- Arreglos, Cadenas de Caracteres, Rutinas de
Ordenamiento y Rutinas de Bsqueda
)
Introduccin
)
Arreglos *
!nidimensionales
+
Cadenas
,,
Bidimensionales
,-
Arreglo de Cadenas ,.
"ultidimensionales ,/
O#eraciones con Arreglos !nidimensionales ,/
Iniciali$acin ,/
%ectura ,0
&scritura ,0
Asignacin ,0
O#eraciones con Arreglos Bidimensionales ,*
Iniciali$acin ,*
%ectura -1
&scritura -1
Asignacin -1
Rutinas de Ordenamiento -,
Intercambio -,
'eleccin --
Insercin -.
Burbuja -/
Rutinas de Bsqueda -0
'ecuencial -0
Binaria -*
Objetivo (.- )unciones y Recursividad 21
Introduccin
21
*e+inicin
2,
!ndice

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina #

*eclaracin
2,
,i#os de )unciones 2-
%lamadas a una )uncin
2.
'alidas de una )uncin 2/
-aso de #ar.metros a una )uncin 2)
-or valor 2)
-or re+erencia 20
/isibilidad de las )unciones 20
Recursividad 2*
/entajas .1
Inconvenientes .1
Consideraciones 0enerales .1
'olucin Iterativa vs 'olucin Recursiva .,
Objetivo 1.- -unteros o A#untadores
..
Introduccin ..
*e+inicin ./
2aturale$a de los -unteros .)
*eclaracin .0
Iniciali$acin .+
O#eraciones de *ireccin e Indireccin /1
Aritm3tica de -unteros /2
Relacin entre Arreglos y -unteros //
-unteros y )unciones /0
-recauciones con el uso de -unteros /*
Objetivo 4.- &structuras
),
Introduccin ),
Conce#tos B.sicos )-
Acceso a los com#onentes de una estructura )2
Arreglos de &structuras )/
&structuras Anidadas )/
!ndice

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $

A#untadores a estructuras ))
-aso de estructuras a las +unciones )0
Objetivo 5.- Arc6ivos
)+
Introduccin )+
,i#os de arc6ivos 0,
Arc6ivos de ,e7to. O#eraciones que se reali$an sobre ellos 0)
Arc6ivos Binarios. O#eraciones que se reali$an sobre ellos *1
&jem#los de -rogramas de Arc6ivos y mani#ulacin *2
%b&eti'o ()* Arreglos+ Cadenas de Caracteres+ Rutinas de
%rdenamiento y Rutinas de ,-s.ueda

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina /

!na estructura de datos es una coleccin de datos que #ueden ser
caracteri$ados #or su organi$acin y las o#eraciones que de+inen en ella. %as
estructuras de datos son muy im#ortantes en los sistemas de com#utadora. %os
ti#os de datos m.s +recuentes utili$ados en los di+erentes lenguajes de
#rogramacin son8

3atos sim4les
&st.ndar &ntero, real, car.cter y lgico
&structura de datos
&st.ticos /ectores y matrices, registro y arc6ivos
*in.micos %ineales8 %ista, #ilas y colas
2o lineales8 9rboles y gra+os

%as estructuras de datos est.ticas son aquellas en las que el tama:o
ocu#ado en memoria se de+ine antes que el #rograma se ejecute y el mismo no
#uede ser modi+icado durante la ejecucin.

%os ti#os de datos que vimos 6asta 6ora son datos sim#les cuya
caracter;stica comn es que cada variable re#resenta a un elemento< en cambio
los ti#os de datos estructurados tienen como #articularidad que con un nombre o
identi+icador se #uede re#resentar mlti#les datos individuales y a su ve$ cada
uno de estas #uede ser re+erenciado inde#endientemente.

Aqu; desarrollaremos los siguientes ;tems8

rreglos
"nidimensionales
Cadenas
5idimensionales
rreglo de Cadenas

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 0

Multidimensionales
O4eraciones con rreglos "nidimensionales
Iniciali%aci6n
Lectura
&scritura
signaci6n
O4eraciones con rreglos 5idimensionales
Iniciali%aci6n
Lectura
&scritura
signaci6n
Rutinas de Ordenamiento
Intercambio
Selecci6n
Inserci6n
5urbu7a
Rutinas de 58s9ueda
Secuencial
5inaria



rreglos

'e de+ine como una coleccin +inita, 6omog3nea y ordenada de
elementos.

Finita: todo arreglo tiene un l;mite, es decir, debe determinarse cual ser. el
nmero m.7imo de elementos que #odr.n +ormar #arte del arreglo.

;omognea: ,odos los elementos de un arreglo son del mismo ti#o o
naturale$a =todos enteros, todos bol3anos, etc.>, #ero nunca una combinacin
de distintos ti#os.

Ordenada: 'e debe determinar cu.l es el #rimer elemento, el segundo, el
tercero? y el en3simo elemento.

ARREGLO

&n C, todos los arreglos constan de #osiciones de memoria contiguas. %a
direccin m.s baja corres#onde al #rimer elemento y la direccin m.s alta al
ltimo elemento. %os arreglos #ueden tener de una a varias dimensiones. &l
arreglo m.s comn es la cadena, que sim#lemente es un arreglo de caracteres
terminado #or un nulo.
1 ELEMENTO 2 ELEMENTO N- ELEMENTO


&n cuanto a las dimensiones los arreglos se #ueden clasi+icar8

!nidimensional o vectores8 un solo ;ndice
Bidimensional o matri$8 dos ;ndices
"ultidimensional8 m.s de dos ;ndices

rreglos "nidimensionales

!n arreglo unidimensional es un ti#o de datos estructurado que est.
+ormado de una coleccin +inita y ordenada de datos del mismo ti#o. &s la
estructura natural #ara modelar listas de elementos iguales.

&l ti#o de acceso a los arreglos unidimensionales es el acceso directo, es
decir, #odemos acceder a cualquier elemento del arreglo sin tener que consultar
a elementos anteriores o #osteriores, esto mediante el uso de un ;ndice #ara cada
elemento del arreglo que nos da su #osicin relativa.

%a +orma general de declaracin de un arreglo unidimensional es8

tipo nombre_de_variable[tamao];

%os arreglos tienen que declararse e7#l;citamente #ara que el com#ilador
#ueda reservar es#acio en memoria #ara ellos. &n la declaracin ti#o declara el
ti#o base del arreglo, que es el ti#o de cada elemento del arreglo. &l valor de
tama:o indica cu.ntos elementos mantendr. el arreglo. -or ejem#lo, #ara
declarar un arreglo de 1@@ elementos de ti#o double denominado 2otas se usa la
instruccin8

double Notas[100];


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina (3

!n elemento se #uede acceder inde7ando el nombre del arreglo. &sto se
6ace colocando el ;ndice del elemento entre corc6etes justo detr.s del nombre
del arreglo. -or ejem#lo,

Notas[3] = 12.23;

asigna al elemento nmero 1 de 2otas el valor 1(.(1.

&n C, todos los arreglos tienen el @ como ;ndice de su #rimer elemento. -or
tanto, cuando se escribe char p[10];se est. declarando un arreglo de caracteres
que tiene die$ elementos, desde #A@B 6asta #ACB. -or ejem#lo, el siguiente
#rograma carga un arreglo de enteros con los nmeros desde el @ 6asta el CC8

#include <stdio.h>
int main(void)
{
int x[100]; /* esto declara un arreglo de 100 elementos enteros /
int t;
/* mostrar el contenido de x */
for(t=0; C<100; t++)
{
x[t]=t; printf("%d ", x[t];
}
return 0;
}

C no com#rueba los l;mites de los arreglos. Como #rogramador, es tarea
suya #ro#orcionar una com#robacin de l;mites cuando sea necesario. -or
ejem#lo, este cdigo com#ilar. sin errores, #ero es incorrecto #orque el bucle +or
6ace que se sobre#ase el +inal del arreglo DD

int XX[50 ]; for(i=0; i<100; i++) XX[i]= i;


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina ((

Cadenas

&l uso m.s comn de los arreglos unidimensionales, es como cadenas de
caracteres. &n C, una cadena es un arreglo de caracteres terminado en nulo. =!n
nulo es un cero.> -or tanto, una cadena contiene los caracteres que la
con+orman seguidos de un nulo. %a cadena terminada en nulo es el nico ti#o de
cadena de+inido en C.

Cuando se declara un arreglo de caracteres #ara una cadena, es
necesario que se declare con un car.cter m.s que la cadena m.s larga que
#ueda contener, esto dejar. sitio #ara el car.cter nulo. -or ejem#lo, #ara
declarar un arreglo A#ellido que contenga una cadena de 6asta (5 caracteres,
se escribir.8

char Apellido[26] ;

C incluye una gran variedad de +unciones de mani#ulacin de cadenas.
%as m.s comunes son las siguientes8

Nombre Funci6n
strc#y=c1, c(> Co#ia c( en c1.
strcat=c1, c(> Concatena c( al +inal de c1.
strlen=c1> *evuelve la longitud de c1.
strcm#=c1, c(> *evuelve @ si c1 y c( son iguales< menor que @ si c1Ec(< mayor que @ si
c1Fc(.
strc6r=c1, car> *evuelve un #untero a la #rimera ocurrencia de car en c1.
strstr=c1, c(> *evuelve un #untero a la #rimera ocurrencia de c( en c1.

&stas +unciones usan el arc6ivo de cabecera est.ndar Estring.6F. &l
siguiente #rograma ilustra el uso de estas +unciones de cadenas8


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina (

#include <stdio.h>.
#include <string.h>
int main(void)
{
char c1[80],c2[80] ;
gets(c1);
gets(c2);
printf("longitudes: %d %d\n", strlen(c1), strlen(c2));
if (strcmp(c1, c2)==0) printf("Las cadenas son iguales\n") ;
strcat(c1, c1);
printf("%s\n",c1) ;
strcpy(c1, "sta es una prueba.\");
printf (c1) ;
if(strchr("hola", 'o')) printf("o est en hola\n");
if(strstr("hola amigos", "hola")) printf("hola encontrado");
return 0;
}

'i se ejecuta este #rograma y se introducen las cadenas G6olaG y G6olaG, la
salida es

longitudes8 4 4
%as cadenas son iguales
6ola 6ola
Hsta es una #rueba
o est. en 6ola
6ola encontrado

rreglos 5idimensionales

&ste ti#o de arreglos al igual que los anteriores es un ti#o de dato
estructurado, +inito ordenado y 6omog3neo. &l acceso a ellos tambi3n es en
+orma directa #or medio de un #ar de ;ndices.

%os arreglos bidimensionales se usan #ara re#resentar datos que #ueden
verse como una tabla con +ilas y columnas. %a #rimera dimensin del arreglo

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina ("

re#resenta las columnas, cada elemento contiene un valor y cada dimensin
re#resenta una relacin.%a re#resentacin en memoria se reali$a de dos +ormas8
almacenamiento #or columnas o #or renglones.

-ara declarar un arreglo num de enteros bidimensional de tama:o 1@,(@ se
escribir.

int num[10] [20];

*e +orma similar, #ara acceder al #unto 1,( del arreglo d se escribir.

num[1][2]

&l siguiente ejem#lo carga un arreglo bidimensional con los nmeros del 1
al 1( y luego los im#rime +ila a +ila.

#include <stdio.h>
int main(void)
{
int t, i, num [3][4];
for (t=0; t<3; ++t)
{
for(i=0; i<4; ++i)
{
num [t][i]=(t*4)+ i + 1;
}
}
/* ahora imprimirlos */
for (t=0; t<3; ++t)
{
for(i=0; i<4; ++i)
{
printf ("%3d ", num[t] [i] ) ;
printf("\n");
}
}

return 0;
}


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina (#

&n este ejem#lo, numA@BA@B tiene el valor 1, numA@BAlB el valor (, numA@BA(B el
valor 1, y as; sucesivamente. &l valor de numA(BA1B es 1(. 'e #uede re#resentar el
arreglo como sigue8

num [t] [i]

1 2 3 4
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12

%os arreglos bidimensionales se almacenan en matrices +ila-columna, en las
que el #rimer ;ndice indica la +ila y el segundo indica la columna. &sto signi+ica
que el ;ndice m.s a la derec6a cambia m.s r.#ido que el de m.s a la i$quierda
cuando accedemos a elementos del arreglo en el orden en que realmente se
6an almacenado en memoria.

rreglos de Cadenas

-ara crear un arreglo de cadenas se utili$a un arreglo de caracteres
bidimensional. &l tama:o del ;ndice i$quierdo determina el nmero de cadenas y
el tama:o del ;ndice derec6o es#eci+ica la longitud m.7ima de las cadenas. &l
cdigo que sigue declara un arreglo de 1@ cadenas, cada una con una longitud
m.7ima de IC caracteres.

char arreglo_cad[30][80];

&s bastante +.cil acceder a una cadena individual8 sim#lemente se
es#eci+ica slo el ;ndice i$quierdo. -or ejem#lo, la siguiente declaracin llama a
gets=> con la tercera cadena de arreglo Jcad.

gets (arreglo_cad[2]) ;


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina ($

%a declaracin anterior equivale +uncionalmente a

gets(&arreglo_cad[2][0]);

rreglos Multidimensionales

&ste tambi3n es un ti#o de dato estructurado, que est. com#uesto #or n
dimensiones. -ara 6acer re+erencia a cada com#onente del arreglo es necesario
utili$ar n ;ndices, uno #ara cada dimensin. C #ermite arreglos de m.s de dos
dimensiones. %a +orma general de declaracin de un arreglo multidimensional es8

tipo nombre [Tamao1][Tamao2][Tamao3]...[TamaoN];

O4eraciones con rreglos "nidimensionales

%as o#eraciones en arreglos #ueden clasi+icarse de la siguiente +orma8
Iniciali$acin
%ectura
&scritura
Asignacin

Iniciali%aci6n

C #ermite la iniciali$acin de arreglos en el momento de declararlos. %a
+orma general de iniciali$acin de un arreglo, que a#arece a continuacin, es
similar a la de otras variables8

especificador_de_tipo nombre_de_arreglo [tamao1 ]...[tamao N]=
{lista_de_valores};

%a listaJdeJvalores es una lista de constantes se#aradas #or comas cuyo
ti#o es com#atible con el es#eci+icadorJdeJti#o. %a #rimera constante se coloca

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina (/

en la #rimera #osicin del arreglo, la segunda constante en la segunda #osicin,
y as; sucesivamente. Obs3rvese que un #unto y coma sigue a K.

&n el ejem#lo que sigue se iniciali$a un arreglo de enteros de 1@ elementos
con los nmeros del 1 al 1@8

int i[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Iniciali%aci6n de arreglos no delimitados

Como se #odr. su#oner, resulta tedioso contar los caracteres de cada
mensaje manualmente #ara determinar la dimensin correcta del arreglo. 'e
#uede 6acer que el com#ilador calcule autom.ticamente las dimensiones de los
arreglos. 'i en una instruccin de iniciali$acin de un arreglo no se es#eci+ica el
tama:o del arreglo, el com#ilador autom.ticamente crea un arreglo
su+icientemente grande #ara mantener todos los iniciali$adores #resentes. &sto es
lo que se denomina arreglo no delimitado.

char mensaje[26] = Bienvenido al Sistema;

Adem.s de ser menos tedioso, el uso de la iniciali$acin de arreglos no
delimitados #ermite cambiar cualquiera de los mensajes sin temor a teclear una
cuenta incorrecta accidentalmente. &l uso de iniciali$aciones de arreglos no
delimitados no est. restringido a los arreglos unidimensionales.



Lectura

&ste #roceso consiste en leer un dato de un arreglo y asignar un valor a
cada uno de sus com#onentes. %a lectura se reali$a de la siguiente manera8
int n = 100; /* donde la variable n contiene la cantidad mxima
que contendr el arreglo*/
for (i=0;i < n-1; i++)
scanf(%d,&arreglo[i]);

&scritura

Consiste en im#rimir o mostrar #or #antalla el valor de cada #osicin del
arreglo. %a escritura se reali$a de la siguiente manera8


for (i=0;i< n-1; i++)
printf(%d,arreglo[i]);

signaci6n

2o es #osible asignar directamente un valor a todo el arreglo, #or lo que se
reali$a de la manera siguiente8

for (i=0;i < n-1; i++)
arreglo[i]= 0;



O4eraciones con rreglos 5idimensionales

%as o#eraciones en arreglos bidimensionales #ueden clasi+icarse de la
siguiente +orma8
Iniciali$acin
%ectura
&scritura
Asignacin
Iniciali%aci6n

%os arreglos multidimensionales se iniciali$an del mismo modo que los
unidimensionales. -or ejem#lo, lo siguiente iniciali$a cuads con los nmeros del 1
al 1@ y sus cuadrados.

int cuads[10] [2] = {
1, 1,
2, 4,
3, 9,
4, 16,
5, 25,
6, 36,
7, 49,
8, 64,
9, 81,
10, 100,
};

Cuando se iniciali$an arreglos multidimensionales se #ueden a:adir llaves
#ara encerrar los iniciali$adores de cada dimensin. &sto se denomina
agru#amiento subagregado. -or ejem#lo, la declaracin anterior se #odr;a 6aber
escrito tambi3n como8
int cuads[10][2] = {
{1, 1},
{2, 4},
{3, 9},
{4, 16},
{5, 25},


{6, 36}};

Cuando se utili$a agru#amiento subagregado, si no se #ro#orcionan
su+icientes iniciali$adores #ara un gru#o dado, los restantes miembros se iniciali$an
a cero autom.ticamente.

Iniciali%aci6n de arreglos no delimitados

-ara los arreglos multidimensionales se deben es#eci+icar todas e7ce#to la
dimensin m.s a la i$quierda. =%as otras dimensiones se necesitan #ermitir al
com#ilador de C inde7ar el arreglo adecuadamente.> *e este modo se #uede
construir tablas de longitudes variables, y el com#ilador asignar.
autom.ticamente su+iciente es#acio #ara ellas. -or ejem#lo, a continuacin se
muestra la iniciali$acin del arreglo no delimitado cuads8

int cuads[] [2] = {
1, 1,
2, 4,
3, 9,
4, 16,
5, 25,
6, 36,
7, 49,
8, 64,
9, 81,
10, 100,
};

%a ventaja de esta declaracin sobre la versin de tama:o delimitado es
que la tabla #uede alargarse o acortarse sin tener que cambiar las dimensiones
del arreglo.



Lectura

&ste #roceso consiste en leer un dato de un arreglo y asignar un valor a
cada uno de sus com#onentes. %a lectura se reali$a de la siguiente manera8
for (i=0;i < n-1; i++)
{
for (j=0;j < n-1; j++)
{
scanf(%d,&arreglo[i][j]);
}
}

&scritura

Consiste en im#rimir o mostrar #or #antalla el valor de cada #osicin del
arreglo. %a escritura se reali$a de la siguiente manera8

for (i=0;i < n-1; i++)
{
for (j=0;j < n-1; j++)
{
printf(%d,arreglo[i][j]);
}
}

signaci6n

2o es #osible asignar directamente un valor a todo el arreglo, #or lo que se
reali$a de la manera siguiente8
for (i=0;i < n-1; i++)
{
for (j=0;j < n-1; j++)
{
arreglo[i][j]= 0;
}
}

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina (

Ordenaci6n y 58s9ueda

%a ordenacin y bsqueda de elementos son tareas que se reali$an
+recuentemente en el #rocesamiento de datos, esto debido a que muc6as
actividades 6umanas requieren que a di+erentes colecciones de datos utili$ados
se #ongan en un orden es#ec;+ico y se localicen de manera r.#ida< ejem#los
claros son las o+icinas de correos y las em#resas de mensajer;a que ordenan el
correo y los #aquetes #or cdigos #ostales, con el +in de conseguir una entrega
e+iciente. %o que su#one un .rea interesante e intr;nseca desde el #unto de vista
terico y #r.ctico en la #rogramacin. -or tal motivo esta unidad est. dedicada
a estudiar los m3todos de ordenamiento y bsqueda, as; como su
im#lementacin en el lenguaje C.

Rutinas de Ordenamiento

1. Ordenaci6n 4or intercambio: es el m3todo m.s sencillo, ordena los
elementos de una lista en orden ascendente. %a t3cnica se basa en la
lectura sucesiva de la lista a ordenar, com#arando el elemento in+erior de
la lista con los restantes y e+ectuando intercambio de #osiciones cuando el
orden resultante de la com#aracin no sea correcto. &l +uncionamiento de
este m3todo se #uede observar gr.+icamente a continuacin8

'e tiene el siguiente arreglo a8
&n la iteraci6n 1 ocurrir;a lo siguiente8
8 4 6 2

'e reali$a intercambio 4 8 6 2

4 8 6 2

2o se reali$a intercambio 4 8 6 2

4 8 6 2


8 4 6 2

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina

Vector inicial Vector resultante

&n la iteraci6n , #asar;a lo siguiente8

2 8 6 4


2 6 8 4



&n la iteraci6n - se tendr;a8
2 4 8 6



Im4lementaci6n del mtodo en C:

void intercambio( int a[], int n )
{
int i, j , aux;
for (i=0;i < n-1; i++)
for (j=i+1;j < n; j++)
if( a[i] > a[j] )
{
aux=a[i];
a[i] = a[j];
a[j] = aux;
}
}

2. Ordenaci6n 4or selecci6n: &l +uncionamiento de este m3todo se #uede
observar gr.+icamente a continuacin8 consid3rese un arreglo a con 5
valores enteros8

51 21 39 80 35


51 21 39 80 35

Iteracin @ 'eleccionar (1 e intercambiar (1 y aA@B
21 51 39 80 35

Iteracin 1 'eleccionar 15 e intercambiar 15 y aA1B
21 35 39 80 51

Iteracin ( 'eleccionar 1C e intercambiar 1C y aA(B
21 35 39 80 51

Iteracin 1 'eleccionar 51 e intercambiar 15 y aA1B
21 35 39 51 80

Iteracin 4 %ista ordenada
*es#u3s de observar gr.+icamente el m3todo se #uede deducir lo siguiente8
&l m3todo selecciona el elemento m.s #eque:o de la lista a. %o
intercambia con el #rimer elemento aA@B. A6ora el valor m.s #eque:o est.
en la #rimera #osicin del vector.
Considerar las #osiciones de la lista aA1B, aA(B, aA1B,?, seleccionar el
elemento m.s #eque:o e intercambiarlo con aA1B. A6ora los dos valores
m.s #eque:os de a est.n en orden.
Continuar este #roceso encontrando o seleccionando el elemento m.s
#eque:o de los restantes intercambiarlos adecuadamente.

void seleccion( int a[], int n )
{
int i, j ,aux, indicemenor;
for (i=0;i < n-1; i++)
{
indicemenor = i;
for (j=i+1;j < n; j++)
{
if( a[j] < a[indicemenor] )
{
aux=a[j];
a[j] = a[indicemenor];
a[indicemenor] = aux;
}
}
}
}



1. Ordenaci6n 4or inserci6n: &l +uncionamiento de este m3todo se #uede
observar gr.+icamente a continuacin8

50

Comien$o con 5@
20 50

'e inserta (@ en la #osicin @ y 5@ se mueve a la
#osicin 1
20 40 50

'e inserta 4@ en la #osicin 1 y 5@ se mueve a la
#osicin (
20 40 50 80

'e inserta L@ en la #osicin 1
20 30 40 50 80

'e inserta 1@ en la #osicin 1 y se des#la$a a la
derec6a la sublista derec6a

*es#u3s de observar gr.+icamente el m3todo se #uede deducir lo siguiente8
&l #rimer elemento aA@B se considera ordenado< es decir, la lista inicial
consta de un elemento.
'e inserta aA1B en la #osicin correcta< delante o detr.s de aA@B,
de#endiendo de que sea menor o mayor. &s decir, se e7#lora la lista desde
aAiB 6asta aAnB buscando la #osicin correcta de destino< esto es la #osicin
a insertar dentro de la lista ordenada.
-or cada iteracin se mueve 6acia a la derec6a del vector todos los
elementos mayores que la #osicin a insertar, #ara dejar vac;a esa
#osicin.
Insertar ele elemento en la #osicin correcta.




void insercion( int a[], int n )
{
int i, j ,aux;
for (i=1;i < n; i++)
{
j = i;
aux=a[i];
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
}

4. Ordenaci6n 4or burbu7a: es el m.s conocido y #o#ular de todos #or su
+acilidad de entender, #ero es el m.s ine+iciente y #or ello, normalmente se
a#rende su t3cnica #ero no suele usarse. 'e denomina burbuja #orque los
valores m.s #eque:os del arreglo suben a la cima del mismo, de manera
similar a como suben las burbujas en el agua, mientras que los valores
mayores se 6unden en la #arte in+erior del arreglo. &l +uncionamiento de
este m3todo se #uede observar gr.+icamente a continuacin sea a el
siguiente arreglo8

&n la iteraci6n 1 se tiene8
50 20 40 80 30

Intercambio 5@ y (@
20 50 40 80 30

Intercambio 5@ y 4@
20 40 50 80 30 5@ y L@ ordenados
50 20 40 80 30


20 40 50 80 30

Intercambio L@ y 1@
20 40 50 30 80

&lemento mayor es L@

&n la iteraci6n , se tiene8
20 40 50 30 80

(@ y 4@ ordenados
20 40 50 30 80

4@ y 5@ ordenados
20 40 50 30 80

Intercambio 5@ y 1@
20 40 30 50 80

5@ y L@ elementos mayores ordenados

&n la iteraci6n - se tiene8
20 40 30 50 80

(@ y 4@ ordenados
20 40 30 50 80

Intercambio 4@ y 1@
20 30 40 50 80

4@, 5@ y L@ elementos mayores ordenados

&n la iteraci6n 2 se tiene8
20 30 40 50 80

(@ y 1@ ordenados
20 30 40 50 80

%ista ordenada



void burbuja( int a[], int n )
{
int j , aux, pasada, interruptor=0;
for (pasada=0; pasada < n-1 && interruptor==0; pasada++)
{
interruptor=1;
for (j=0;j < n-pasada-1; j++)
{
if( a[j] > a[j+1] )
{
interruptor=0;
aux=a[j];
a[j] = a[j+1];
a[j+1] = aux;
}
}
}
}
Rutinas de 58s9ueda

1. 58s9ueda secuencial: esta bsqueda trata de buscar un elemento de un
arreglo utili$ando un valor destino llamado clave. &n una bsqueda
secuencial, los elementos de una lista o vector se e7#loran en secuencia, es
decir uno des#u3s del otro. &ste m3todo com#ara cada elemento del
arreglo con la clave de bsqueda. *ado que el vector no est. en un orden
#re+ijado, es #robable que el elemento a buscar #ueda ser el #rimero, el
ltimo o cualquier otro.

&l siguiente ejem#lo es#eci+ica gr.+icamente el m3todo, en la cual
se trata de buscar el elemento M en el siguiente arreglo a8



10 05 31 22 06

6 valor devuelto ;ndice 4

int busqueda_secuencial(int a[], int n, int clave)
{
int i;
for(i=0; i<n; i++)
if(a[i]==clave)
return 1;
return -1;
}

2. 58s9ueda binaria: si un vector est. ordenado, se le #uede a#licar esta
bsqueda, que +unciona de la siguiente manera8 se #osiciona en el centro
de la lista y se com#rueba si el valor clave coincide con el valor del
elemento central. 'i no encuentra el valor de la clave, se sita en la mitad
in+erior o su#erior del elemento central de la lista. 0r.+icamente esta
t3cnica se #uede re#resentar de la siguiente manera8

'e desea buscar ((5 en el siguiente vector a:

Punto central (100)
13 44 75 100 120 275 325 510
Como ((5 es mayor que 1@@, la
bsqueda contina con la mitad
su#erior del conjunto de datos del
vector.

13 44 75 100 120 275 325 510


120 275 325 510

&l ltimo valor de la #rimera mitad es
(I5, la bsqueda contina con la
#rimera mitad de elementos.

120 275

&l ltimo valor de la #rimera mitad es
1(@, que es m.s #eque:o que el valor
que se est. buscando, la bsqueda
contina con la segunda mitad de
elementos.

275

'e observa #or ltimo que no 6a
6abido 37ito en la bsqueda ya que
((L es distinto a (I5

int busquedabinaria (int a[], int bajo, int alto, int clave)
{
int central, valorcentral;
while(bajo<=alto)
{
central = (bajo+alto)/2;
valorcentral = a[central];
if(clave == valorcentral)
return central;
else if(clave < valorcentral)
alto = central -1;
else
bajo = central + 1;
}
return -1;
}
%b&eti'o )* 4unciones y Recursi'idad

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina "3

Cuando se 6abla de modularidad en %enguaje C se em#lea el t3rmino
+uncin que no es m.s que una seccin de cdigo inde#endiente que genera un
conjunto de eventos derivados de una #osterior llamada en una #arte de la
seccin #rinci#al del #rograma, lo que conlleva que se #ueda trabajar en una
+orma m.s ordenada y generando a#licaciones m.s robustas y #oderosas
combinando ejecuciones iterativas yNo recursivas.

Introducci6n
3e#inici6n
3eclaraci6n
!i4os de Funciones
Llamadas a una Funci6n
Salidas de una Funci6n
(aso de 4ar'metros a una Funci6n
(or valor
(or re#erencia
<isibilidad de las Funciones
Recursividad
<enta7as
Inconvenientes
Soluci6n Iterativa vs Soluci6n Recursiva


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina "(

3e#inici6n
!na #unci6n es una #arte de cdigo inde#endiente del #rograma #rinci#al
y de otras +unciones, que #uede ser llamada envi.ndole unos datos =o sin enviarle
nada>, #ara que realice una determinada tarea yNo #ro#orcione unos resultados.
%a +orma general de de+inicin de una +uncin es8
tipo nombre(lista de parmetros)
{
cuerpo de la funcin
}
&l ti#o es#eci+ica el ti#o de valor que devuelve la sentencia return de la
+uncin. &l valor #uede ser cualquier ti#o v.lido< si no se es#eci+ica ninguno, se
asume un resultado entero. %a lista de #ar.metros es la lista de nombres de
variables se#arados #or comas con sus ti#os asociados que reciben los valores de
los argumentos cuando se llama a la +uncin. !na +uncin #uede no tener
#ar.metros, en cuyo caso la lista de #ar.metros est. vac;a< sin embargo, los
#ar3ntesis son necesarios.
3eclaraci6n
Cada +uncin debe ser declarada. 'u +orma general es8 ti#o
nombreJ+uncin =lista de ti#os =y nombres> de los argumentos>< si una +uncin va
usar argumentos, debe declarar variables que ace#ten los valores de los
argumentos. &stas variables se llaman #ar.metros +ormales de la +uncin y se
com#ortan como variables locales dentro de la +uncin, cre.ndose al entrar en la
+uncin y destruy3ndose al salir. %a declaracin de #ar.metros a#arece des#u3s
del nombre de la +uncin al de+inirla. %os #ar.metros +ormales tienen que ser del
mismo ti#o que los argumentos usados al llamar una +uncin =el com#ilador no
dar. error #ero los resultados ser.n ines#erados>.


Al igual que con variables locales, se #ueden 6acer asignaciones a los
#ar.metros de una +uncin o usarlos en cualquier e7#resin v.lida. 'e #ueden
usar como cualquier otra variable.
!na +uncin es visible #ara ella misma y otras +unciones desde el momento
en que se de+ine. &s visible #ara el #ro#io cuer#o de la +uncin, es decir, la
recursividad est. #ermitida. &l cdigo de una +uncin es #rivado a esa +uncin y
slo se #uede acceder a 3l mediante una llamada a esa +uncin. %as variables
de+inidas dentro de una +uncin son locales =a no ser que las de+inamos globales>
#or lo que no conservan su valor de una llamada a otra =e7ce#to si se declaran
como static, entonces el com#ilador no las destruye y almacena su valor #ara la
#r7ima llamada, aunque la variable tiene limitado el .mbito al interior de la
+uncin>.
&n C, todas las +unciones est.n al mismo nivel, es decir, no se #uede de+inir
una +uncin dentro de otra +uncin. &sto es #or lo que C no es t3cnicamente un
lenguaje estructurado #or bloques.
&l cdigo de una +uncin es #rivado a esa +uncin y slo se #uede acceder
a 3l mediante una llamada a esa +uncin. %as variables de+inidas dentro de una
+uncin son locales =a no ser que las de+inamos globales> #or lo que no conservan
su valor de una llamada a otra =e7ce#to si se declaran como static, entonces el
com#ilador no las destruye y almacena su valor #ara la #r7ima llamada, aunque
la variable tiene limitado el .mbito al interior de la +uncin>.

!i4os de Funciones
"uc6os autores establecen la siguiente clasi+icacin a la 6ora de ti#i+icar
las +unciones en %enguaje C8
a. Funciones 9ue no tienen 4ar'metros y 9ue no devuelven ning8n
valor: 'on aquellas que no tienen #ar.metros de entrada, reali$an
acciones en su cuer#o de #rograma y no devuelven ningn valor.
!tili$an la #alabra reservada void como ti#i+icador de datos

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina ""

&7em4lo:
void mostrar(void)
{
printf("Despliegue de datos");
return;
}

b. Funciones 9ue tienen 4ar'metros y 9ue no devuelven ning8n valor:
'on aquellas que tienen #ar.metros de entrada, reali$an acciones
en su cuer#o de #rograma y no devuelven ningn valor. !tili$an
cualquiera de las #alabras reservadas como ti#i+icadores de datos
a nivel de los #ar.metros de entrada en cuanto a la +uncin su
ti#i+icador es void
&7em4lo:
void mostrar_suma(int a, int b)
{
int suma;
suma= a+b;
printf("La Suma de A y B es:%d, suma);
return;
}

c. Funciones 9ue no tienen 4ar'metros y 9ue devuelven valor: 'on
aquellas que no tienen #ar.metros de entrada, reali$an acciones en
su cuer#o de #rograma y devuelven algn valor. !tili$an cualquiera
de las #alabras reservadas como ti#i+icadores de datos a nivel de
+uncin.
&7em4lo:
int suma(void)
{
int a=10, b=20, suma;
suma = a+b;
return suma;
}

d. Funciones 9ue tienen 4ar'metros y 9ue devuelven valor: 'on
aquellas que tienen #ar.metros de entrada, reali$an acciones en su

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina "#

cuer#o de #rograma y devuelven algn valor. !tili$an cualquiera de
las #alabras reservadas como ti#i+icadores de datos a nivel de los
#ar.metros de entrada y de +uncin
&7em4lo:
int suma(int a, int b)
{
int sumando;
sumando = a+b;
return sumando;
}

Llamadas a Funciones
%as +unciones son llamadas #ara su ejecucin desde cualquier #arte del
cdigo, teniendo en cuenta que antes deben 6aber sido declaradas =y #or
su#uesto de+inidas>.
%a llamada de una +uncin se #roduce mediante el uso de su nombre en
una sentencia, #asando una lista de argumentos que deben coincidir en nmero
y ti#o con los es#eci+icados en la declaracin =en otro caso se #roducir;a una
conversin de ti#os o resultados ines#erados>.
&n general, se #ueden #asar argumentos a las +unciones de dos +ormas, #or
valor y #or re+erencia.
%a llamada 4or valor co#ia el valor de un argumento en el #ar.metro
+ormal de la +uncin. *e esta +orma, los cambios en los #ar.metros de la +uncin
no a+ectan a las variables que se usan en la llamada =es la llamada m.s usual, es
decir, en general no se #ueden alterar las variables usadas #ara llamar a la
+uncin>.
%a llamada 4or re#erencia co#ia la direccin del argumento en el
#ar.metro. *entro de la +uncin se usa la direccin #ara acceder al argumento
usado, signi+icando que los cambios 6ec6os a los #ar.metros a+ectan a la
variable usada en la llamada.

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina "$

&s #osible simular una llamada #or re+erencia #asando un #untero al
argumento, entonces, al #asar la direccin, es #osible cambiar el valor de la
variable usada en la llamada.
&7em4lo:
#include <stdio.h>

void holamundo(void) /*Funcin donde se ejecuta la lgica del
programa*/
{
printf("Hola Mundo\n"); /*imprime la cadena*/
return; /*sale de la funcin*/
}

int main(void) /*Funcin principal del programa*/
{
holamundo(); /*llamada a la funcin que lleva el peso*/
return 0; /*sale del programa: correcto*/
}

Salidas de Funciones
-ara salir de un +uncin se utili$a la sentencia return que #roduce la salida
inmediata de la +uncin 6acia el cdigo que la invoc. %a sentencia #uede
devolver un valor acorde con el ti#o usado al declarar la +uncin que #uede ser
una constante, una variable o una e7#resin. &n caso de obviarse la sentencia
return, la +uncin terminar. con se ejecucin de la ltima instruccin. &n este caso
la +uncin devuelve el valor cero a e7ce#cin de las +unciones de ti#o void, que
no devuelve ningn valor.
&7em4lo:

void holamundo(void) /*Funcin donde se ejecuta la lgica del
programa*/
{
printf("Hola Mundo\n"); /*imprime la cadena*/
return; /*sale de la funcin*/
}

int suma(int a, int b) /*Funcin donde se ejecuta la lgica del
programa*/

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina "/

{
int sum;
sum = a+b;
return sum; /*sale de la funcin*/
}

(aso de 4ar'metros a una Funci6n
%os #ar.metros +ormales de una +uncin son variables locales que se crean
al comen$ar la +uncin y se destruyen cuando termina. &l ti#o de dato de cada
#ar.metro +ormal debe ser el mismo que el ti#o de los argumentos se utilicen al
llamar a la +uncin. &ste error no se detecta en la com#ilacin y #ara remediarlo,
se deben usar los #rototi#os de +unciones. &l nico caso en el que los ti#os #ueden
no coincidir los #ar.metros +ormales y los argumentos es cuando el argumento es
de ti#o c6ar y el #ar.metros +ormal es de ti#o int< la conversin, en este caso, se
6ace a int. %os #ar.metros de una +uncin #ueden ser valores =llamada 4or valor>
o direcciones =llamada 4or re#erencia>
(or valor: &l #ar.metro de la +uncin recibe el valor de la variable que
se utili$a como argumento. Cualquier modi+icacin sobre estos
#ar.metros no a+ecta a las variables que se utili$an #ara llamar a la
+uncin, #uesto que el #ar.metro en estos casos es una co#ia de la
variable. 'olo se #ueden #asar #or valor los ti#os atmicos, es decir no
son arrays ni estructuras.
&jm8
int suma(int a, int b);
main()
{
int x = 1, y = 2, z;

z = suma(x, y);

}

int suma(int a, int b)
{
return(a + b);
}



(or re#erencia: Cuando un argumento es una direccin, el #ar.metro
recibe la direccin de la variable que se 6a #asado como argumento
al invocar a la +uncin. -or lo tanto, el #ar.metro deber. declararse
como un #untero y de esta +orma se #uede modi+icar el contenido de
las variables. 'i una +uncin tiene que devolver m.s de un valor, lo 6ar.
utili$ando sus #ar.metros y necesariamente los argumentos deben
#asarse #or re+erencia.

&jm8
a>
void cursor(int *x, int *y);
main()
{
int fila, columna;

cursor(&fila, &columna);

}

void cursor(int *x, int *y)
{
....
*x =20;
.....
}

b>

void alternar int *px, int *py);
main()
{
int x = 10, y = 20;
alternar(&x, &y);
printf("x = %d, y = %d", x,y);
}

void alternar(int *px, int *py)
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}



<isibilidad de una Funci6n
!na +uncin declarada en un arc6ivo tiene un alcance global< es
decir, se #uede invocarla desde cualquier #unto dentro este arc6ivo.

Cuando se quiere acceder a ella desde otro arc6ivo, 6ay que incluir
en este ltimo la declaracin de dic6a +uncin. A di+erencia de las
variables e7ternas, donde es necesario modi+icar el ti#o de
almacenamiento mediante la #alabra reservada e7tern, las +unciones no
necesitan de este modi+icador8 una +uncin #uede ser invocada desde
cualquier mdulo. &l uso de la #alabra e7tern se usa #ara +acilitar la
com#resin del cdigo. 'i quiere restringir el uso de la +uncin a un solo
mdulo, se usa el modi+icador static en su declaracin. &sta caracter;stica
#ermite dise:ar mdulos con in+ormacin y 6erramientas #rivadas.

Recursividad
Oasta a6ora se 6a trabajado en lenguaje C dando soluciones
iterativas a nuestros algoritmos. Con este estudio de la recursividad se
#retende que se entienda la di+erencia entre una solucin iterativa y su
versin recursiva viendo las ventajas e inconvenientes que la utili$acin de
una u otra a#ortan. &jm8 ?C6mo dise@ar una #unci6n 9ue calcule la
4otencia de AB 'e #uede llegar al siguiente #lanteamiento8

'e #odr;a #ensar en la +rmula de la #otencia de la manera siguiente8

#ot=D,n> P D Q #ot=D, n-1>


#ot=D,n-1> P D Q #ot=D, n-(>
.
.
#ot=D,@> P 1

'e dice que es recursiva ya que la de+inicin se da en t3rminos de
una versin m.s #eque:a de s; misma. !n algoritmo recursivo es un
algoritmo que e7#resa la solucin de un #roblema en t3rminos de una
llamada a s; mismo. %a llamada a s; mismo se conoce como llamada
recursiva.

&7em4lo:
void funcionRecursiva(int a)
{

funcionRecursiva(a+1);

}

-ara que un algoritmo recursivo no se convierta en in+inito debe
contener una condicin que garantice la terminacin del algoritmo
recursivo en un tiem#o +inito. &s lo que se conoce como CON3ICICN 3&
(R3, que debe 6acer que no se generen m.s llamadas recursivas.

,ambi3n debe contener un (SO 3& L R&C"RSI<I33, que
garantice que al ejecutar el algoritmo recursivo se tiende a la condicin de
#arada. !na +uncin declarada en un arc6ivo tiene un alcance global< es
decir, se #uede invocarla desde cualquier #unto dentro este arc6ivo.
Cuando se quiere acceder a ella desde otro arc6ivo, 6ay que incluir en
este ltimo la declaracin de dic6a +uncin. A di+erencia de las variables
e7ternas, donde es necesario modi+icar el ti#o de almacenamiento
mediante la #alabra reservada e7tern, las +unciones no necesitan de este

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina #3

modi+icador8 una +uncin #uede ser invocada desde cualquier mdulo. &l
uso de la #alabra e7tern se usa #ara +acilitar la com#resin del cdigo. 'i
quiere restringir el uso de la +uncin a un solo mdulo, se usa el modi+icador
static en su declaracin. &sta caracter;stica #ermite dise:ar mdulos con
in+ormacin y 6erramientas #rivadas.

<enta7as
-ro#orciona sim#licidad en la com#rensin de los #roblemas.
&s un m3todo natural de resolver #roblemas.
-ermite una gran #otencia de c.lculo.
%a correccin de los algoritmos se com#rueba +.cilmente.

Inconvenientes
Aumenta el consumo de recursos de la m.quina =sobre todo de la
#ila>.
&s m.s lenta que las soluciones iterativas equivalentes =siem#re que
e7ista la solucin iterativa equivalente>.

Se recomienda aplicar una solucin iterativa cuando el
nmero de clculos que se repiten sea grande o exista
una solucin iterativa que sea sencilla de codificar.

Consideraciones Generales
&n las llamadas a +unciones8
%os #ar.metros que se #asan
%as variables locales de las +unciones
%a direccin de retorno de esa llamada =la instruccin del algoritmo
llamante a ejecutar cuando +inalice la ejecucin del algoritmo
llamado>

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina #(

Se almacenan en la pila del programa.

Soluci6n Iterativa vs Soluci6n Recursiva
lgoritmo 9ue dado un n8mero im4rime su valor y todos los anteriores a
l en orden decreciente.
Solucin iterativa:
void decrementa(int a)
{
int i;
for (i=a;i>0;i--)
printf(%d ,i);
printf(Fin del algoritmo iterativo \n);
}
In+ormacin que a#arece #or #antalla si se 6ace la llamada a la
+uncin decrementa =5>8
5 4 1 ( 1 )in del algoritmo iterativo

Solucin recursiva
void decrementa(int a)
{
if (a>0) !"#$%!%&# $' ()*)$)+ a==0
{
printf(%d ,a);
decrementa(a-,); -()." $' /) *'!0*.%1%$)$-
}
el2e
printf(Fin del algoritmo rec3r2ivo \n);
}

In+ormacin que a#arece #or #antalla si se 6ace la llamada a la
+uncin decrementa =5>8
5 4 1 ( 1 )in del algoritmo recursivo

%a siguiente +igura ilustra la ejecucin #aso a #aso del algoritmo recursivo8

A la vuelta de la recursividad no se ejecuta ninguna sentencia.


*ado el siguiente ejem#lo analice el caso e indique la secuencia de
valores que se im#rimen.

void main(void)
{
(4(5);
}
void (4(int a)
{
printf(%d \t,a);
if (a>0) !"#$%!%&# $' ()*)$), a==0
{
a--;
(4(a); ()." $' /) *'!0*.%1%$)$
}
printf(%d \t,a);-!36ndo 2e e7ec3ta e2ta 2entencia -
}

%a siguiente +igura muestra la ejecucin #aso a #aso del algoritmo anterior8

A la vuelta de la recursividad se ejecuta la sentencia8

printf(%d \t,a); - (8) -

In+ormacin que a#arece #or #antalla
5 4 1 ( 1 @ @ @ 1 ( 1 4
Calcule la +uncin +actorial de +orma iterativa y recursiva.


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina #"

Soluci6n Iterativa Soluci6n Recursiva
int +actorial=int n>
R
int i<
int +actP1<
+or =iP n< iF@ <i-->
+actP+actS=i><
return=+act><
K

int +actorial=int n>
R
int +act<
i+ =n PP @> NS CO2*ICIT2 *& -ARA*A SN
+act P 1<
else
+act P n S +actorial =n - 1><
NS -A'O *& %A R&C!R'I/I*A* SN
return=+act><
K

'eguimiento de la versin recursiva de la +uncin +actorial8

%b&eti'o ")* Punteros o Apuntadores

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina ##

&n los cursos de #rogramacin el estudio de los #unteros siem#re se 6a
considerado un reto #ara los alumnos, tanto en el a#rendi$aje como en su
a#licacin. &n el lenguaje de #rogramacin C, los a#untadores son una de las
caracter;sticas m.s #oderosas y tiles, en el desarrollo de #rogramas. &l manejo
de #unteros requiere que el alumno modi+ique su +orma de #ensar con res#ecto
al uso de los identi+icadores. %os #unteros son variables que almacenan como
valor la direccin de memoria que ocu#a otro dato =una variable, constante,
elementos de arreglos, +unciones, entre otras>< en otras #alabras, los #unteros
6acen re+erencia a un ti#o de dato almacenado en memoria.

&sta ca#acidad de los #unteros #ermite que re+erencias a +unciones,
#uedan ser utili$adas como argumentos en el llamado a otra +uncin.

%os #unteros guardan una relacin muy estrec6a con los arreglos y
cadenas, #ro#orcionando una v;a alternativa #ara acceder a los elementos
individuales del arreglo. %os #unteros son el elemento +undamental en la creacin
de estructuras de datos din.micas =listas, #ilas, colas, listas enla$adas, .rboles y
gra+os>, a trav3s de la asignacin din.mica de memoria.

3e#inici6n
Naturale%a de los (unteros
3eclaraci6n
Iniciali%aci6n
O4eraciones de 3irecci6n e Indirecci6n
ritmtica de (unteros
Relaci6n entre rreglos y (unteros
(unteros y Funciones
(recauciones con el uso de (unteros


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina #$

3e#inici6n

!n #untero o un a#untador es una variable que almacena como dato la
direccin de memoria de otro identi+icador como #uede ser un arreglo, una
+uncin u otra variable. %os #unteros son variables que almacenan como valor la
direccin de memoria que ocu#a otro dato =una variable, constante, elementos
de arreglos, +unciones, entre otras>< en otras #alabras, los #unteros 6acen
re+erencia a un ti#o de dato almacenado en memoria. &sta ca#acidad de los
#unteros #ermite que re+erencias a +unciones, #uedan ser utili$adas como
argumentos en el llamado a otra +uncin.

Oasta los momentos 6ab;amos visto variables cuyos datos #od;an ser
valores de ti#o num3rico, al+anum3rico y lgico o booleanos, a6ora estamos
conociendo otro ti#o de dato, como lo son las direcciones de memoria, que son
ca#aces de almacenarlas en una variable es#ecial conocida como a#untador.

%os #unteros #ueden ser usados #ara8
)undamentalmente son usados #ara el manejo de memoria en
+orma din.mica, #ermitiendo un uso m.s e+iciente de este recurso.
Comunicar in+ormacin entre una +uncin y sus #untos de llamada.
-ermite devolver varios datos desde una +uncin mediante los
argumentos de la +uncin.
-ermiten que re+erencias a otras +unciones #uedan ser es#eci+icadas
como argumentos de otra +uncin. =#asar +unciones como
argumentos>.
Los punteros, son identificadores (variables) que poseen como
valor la direccin de memoria que ocupa un dato especfico. El
nombre de un puntero hace referencia directa a la posicin de
memoria que ocupa un tipo de dato, e indirecta al valor de ese
dato.


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina #/

Re#resentan de una +orma m.s conveniente los arreglos
multidimensionales, #ermitiendo que un arreglo multidimensional sea
reem#la$ado #or un array de #unteros de menor dimensin.
'on el so#orte de enlace que utili$an estructuras avan$adas de
datos en memoria din.mica como las listas, #ilas, colas y .rboles.

Naturale%a de los (unteros

&ntender cmo trabajan los #unteros requiere un re#aso de cmo se
almacenan los datos en memoria. -rimero debemos recordar que la memoria
est. com#uesta #or celdas de memoria y cada celda #osee dos .reas, una que
es la direcci6n =valor +ijo #ermite identi+icar la #osicin de dic6a celda> y la otra es
la in#ormaci6n =dato almacenado en la celda>. Al momento de declarar una
variable, #or ejem#lo int 7, el com#ilador le asigna a 7 una direccin de memoria,
+ija, donde almacenar. su valor. %os valores almacenados en memoria ocu#an
una o m.s celdas contiguas de memoria =#alabras o bytes adyacentes>. &l
nmero de celdas de memoria requeridas #ara almacenar un valor de#ende del
ti#o de dato. -or ejem#lo, un car.cter ser. almacenado en 1 byte =L bits> de
memoria< un entero normalmente necesita ( bytes continuos. !n valor #unto
+lotante #uede necesitar 4 u L bytes. -ara acceder a un valor de una variable,
almacenado en memoria, se 6ace mencin al nombre de la variable.

int 7<
7 P 4<
#rint+=GUdG,7><

Oay dos o#eradores de a#untadores8 D y E. D es un o#erador monario que
devuelve la direccin de memoria de su o#erando. =Recu3rdese que un
o#erador monario slo necesita un o#erando.>

Celda de Memoria
3irecci6n F <alor F
)L& 4


&l segundo o#erador de a#untadores, E, es el com#lemento de D. &s un
o#erador monario que devuelve el valor que se encuentra en la direccin que le
sigue.
&7em4lo:
'u#ongamos que v es una variable que re#resenta un determinado dato.

&l com#ilador autom.ticamente asignar. celdas de memoria #ara este
dato. -odemos acceder a los datos si conocemos su locali$acin =la direcci6n>
de la #rimera celda de memoria. %a direccin de memoria de v #uede se
determinada mediante la e7#resin Dv. A6ora vamos asignar la direccin de v a
otra variable llamada, #v. As;, #v P Vv
&sta nueva variable =#v> es un #untero a v, #uesto que GG4untaHH a la
#osicin de memoria donde se almacena v, #v re#resenta la direccin de v y no
su valor, #v es re+erida como una variable a#untadora, %a relacin entre v y #v
est. ilustrada en la +igura siguiente
3irecci6n de v

<alor de v
#v

v

&l dato re#resentado #or v =es decir, el dato almacenado en las celdas de
memoria de v> #uede ser accedido mediante la e7#resin S#v, donde S es el
o#erador indireccin, que o#era slo sobre una variable #untero. -or tanto< S#v y
v re#resenta el mismo dato =el contenido de las mismas celdas de memoria>.

3eclaraci6n
Cuando se declara un #untero, como es una variable, el com#ilador
tambi3n le asigna celdas de memoria +ija, #ero el dato que almacena es la
direccin de memoria de otro identi+icador, que #osee el mismo ti#o de dato que
el #untero. %os #unteros, como son identi+icadores, al ser declarados deben tener
un ti#o de dato asociado =num3rico, al+anum3rico o lgico>, y este ti#o de dato


debe ser igual al ti#o de dato de la variable que ocu#a la direccin de memoria
que el #untero almacena. -ara declarar un #untero se reali$a igual que el resto
de las variables, #ero al nombre del #untero le #recede el s;mbolo E =asterisco>,
que leeremos I4untero aJ. &ntonces se dice que un #untero a#unta a un ti#o de
datos es#ec;+ico.
SintaFis:

E,i#oJdatoFS EnombreJ#unteroF<

equivale a

E,i#oJdatoF SEnombreJ#unteroF<

*onde8
!i4oKdato: &s el ti#o de dato del #untero.
NombreK4untero: &s el nombre del #untero

&7em4lo:

intE 8 es un ti#o de dato #untero a enteros.
#loat E8 es un ti#o de dato #untero a datos ti#o +loat.
#loatE 4tryL #try, es un #untero que a#unta a ti#os de datos +loat.
int E4trFL #tr7, es un #untero que a#unta a ti#os de datos enteros.

,ambi3n se #uede decir8

E4trF, es una variable que almacena direcciones de memoria que
contienen ti#os de datos int =enteros>.
E4try, es una variable que almacena direcciones de memoria que
contienen ti#os de datos +loat.

'e debe tener muy claro que G#tr7G es una variable del ti#o G#untero a intG,
que GS#tr7G NO es una variable de ti#o GintG.


3eclaraciones de (unteros

int S-untAInt< MM !i4o 4untero a enteros =int>
c6ar S-untACar< MM !i4o 4untero a caracteres =cNar>
double S#unto< MM !i4o 4untero a double

!n #untero, #uede a#untar a cualquier ti#o de dato de+inido #or el usuario,
no slo a ti#os sim#les. &s muy im#ortante tener en cuenta que #rimero debe
declararse el ti#o de datos al que a#unta =un array, clase, +uncin, etc.> y
des#u3s el ti#o de datos #untero.

Iniciali%aci6n

Como #asa con todas las variables en C, cuando se declara un #untero
slo se reserva el es#acio de memoria #ara almacenarlo, #ero no se asigna
ningn valor inicial, el contenido de la variable #untero #ermanecer. sin cambios,
de modo que el valor inicial del #untero ser. aleatorio e indeterminado
=denominado com8nmente como basura>. *ebemos su#oner que contiene una
direccin no v.lida de memoria. Al intentar reali$ar o#eraciones con #unteros NO
INICILIO3OS, ocurrir. un error no slo en el #rograma, sino tambi3n en el
sistema o#erativo, #orque se intenta acceder a una direccin de memoria NO
&AIS!&N!& o NO <PLI3. ,odos los #unteros deben ser iniciali$ados antes de ser
utili$ados.

A las variables de ti#o #unteros slo #ueden asign.rseles8
el valor cero =1 o la constante N"LL >,
otro #untero con el mismo ti#o de dato,
una direccin de memoria de una variable que #osea el mismo ti#o
de dato que el #untero. %as direcciones de memoria deben ser
asignadas slo con el o#erador de direccin D =am#ersand>.

(unteros Nulos:
int S#tr7 P @<

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $3

+loat S#try P 2!%%<
int S#tr$<

&s #osible reali$ar la asignacin de un #untero a otro, si ambos son del
mismo ti#o de datos.

#tr$ P #tr7< NNel #untero #tr$ recibe la direccin de memoria que tiene
almacenada el #untero #tr7.

O4eradores de 3irecci6n e Indirecci6n

O4erador de 3irecci6n o Re#erencia. =O4erador D>. &s un o#erador monario
=slo requiere un o#erando> que devuelve la direccin de memoria del
o#erando, es decir, lo que 6ace es devolver la direccin que en memoria ocu#a
el objeto sobre el que se a#lica. %iteralmente signi+ica Ila direcci6n deJ.

!n ejem#lo de su uso #ara iniciali$ar un #untero es8
int 7 P1@<
int S#tr7 P V7<

#tr7, #osee como valor la direccin de memoria que ocu#a la
variable 7.

&ntonces se dice que #tr7 a#unta a 7

Celda de Memoria ptrx
3irecci6n <alor
@7)L& @7)LA
Celda de Memoria x
3irecci6n <alor
@7)LA 1@

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $(

%a re#resentacin gr.+ica

&ste o#erador NO es a#licable a e7#resiones constantes, #ues 3stas no se
almacenan en ninguna direccin de memoria es#ec;+ica sino que se incrustan en
las instrucciones. -or ello, no es v.lido 6acer directamente8

int #7 P V1@< NN &rror 1@ no es una variable con direccin #ro#ia

,am#oco es v.lido a#licar D a variables declaradas con la clase de
almacenamiento register, ni cam#os de slo lectura =readonly>, #ues si 3stos
#udiesen ser a#untados #or #unteros se correr;a el riesgo de #oderlos modi+icar
ya que a trav3s de un #untero se accede a memoria directamente, sin tenerse en
cuenta si en la #osicin accedida 6ay algn objeto, #or lo que muc6o menos se
considerar. si 3ste es de slo lectura.

NO!: &l o#erador D #uede a#licarse slo a o#erandos lvalue =algo a lo
9ue se 4uede asignar un valorQ como una variable>.

O4erador de Indirecci6n o 3esre#erencia de memoria. =O4erador E>: &s un
o#erador monario que acta slo sobre o#erandos de ti#o #untero. &ste
o#erador devuelve el valor de la variable a la que a#unta el #untero. &s decir,
devuelve el valor almacenado en la direccin de memoria a#untada #or el
#untero. %iteralmente signi+ica Iel valor deJ.
&7em4lo:
int 7 P 1@<
int S#tr7 P V7<
int $ <
$ P S#tr7 < NN se asigna a la variable $ el valor 1@.
Puntero Variable
ptrx x
10
x
ptrx


Con el o#erador de Indireccin =E>, tambi3n se #ueden asignar valores a
una direccin de memoria a#untada #or un #untero, es decir, se #uede alterar el
valor de la variable a la que a#unta un #untero.

&7em4lo:
int 7 P 1@<
int S#tr7 P V7<
S#tr7 P 1@< NN se asigna a la variable 7 el valor 1@.

NO!: 2o debemos con+undir el o#erador S en la declaracin
del #untero =int S#>, con el o#erador S =asterisco> en las
instrucciones =S#P1@ o $PS#>.

2o se #uede desre+erenciar un #untero 2!%%, #roduce un error en tiem#o
de ejecucin.
&7em4lo re#erenciando:

#include<stdio.h>

int main(void)
{
int x = 99;
int *p1, *p2;

p1 = &x;
p2 = p1;

/* imprimir el valor de x dos veces */
printf(Valores apuntados por p1 y p2: %d %d\n, *p1, *p2);

/* imprimir la direccin de x dos veces */
printf(Direcciones en p1 y p2: %p %p\n, p1, p2);

return 0;
}

,ras la secuencia de asignaciones
#1 P V7<
#( P #1<

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $"

tanto #1 como #( a#untan a 7. -or tanto, tanto #1 como #( se re+ieren al
mismo objeto. A continuacin se muestra un ejem#lo de salida del #rograma,
con+irmando esto.

/alores a#untados #or #1 y #(8 CC CC
*irecciones en #1 y #(8 @@M1)&@@ @@M1)&@@

Obs3rvese que las direcciones se muestran usando el modi+icador de
+ormato de #rint+= > U#. que 6ace que #rint+= > muestre una direccin en el
+ormato utili$ado #or la com#utadora en cuestin.

&7em4lo desre#erenciando:

{
int* puntero;
int variable;

puntero = &variable;
*puntero = 33; /* mismo efecto que variable=33 */
}

/arios a#untadores #ueden a#untar a la misma variable8
int* puntero1;
int* puntero2;
int var;

puntero1 = &var;
puntero2 = &var;
*puntero1 = 50; /* mismo efecto que var=50 */
var = *puntero2 + 13; /* var=50+13 */

ritmtica de (unteros

%os A#untadores #ueden ser utili$ados como o#erandos v.lidos en los
siguientes ti#os de e7#resiones8
Aritm3ticas.
Relacionales.

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $#

%os a#untadores no #ueden ser utili$ados como o#erandos v.lidos con
todos los o#eradores. %os a#untadores slo #ueden reali$ar8

O4eraciones ritmticas:
o Sumarle o restarle un valor entero: IncrementoM3ecremento.
&7em4lo:
#tr7WW< #tr7--< WW#tr7< --#tr7<
#tr7P#tr7W5 < #tr7P#tr7-4< #tr7WP1< #tr7-P(<

o Restar un a4untador de otro. Resta de direcciones de
memoria.
&7em4lo:
#tr7 P #tr7 X #try<

O4eraciones Relacionales: &s #osible com#arar dos variables de ti#o
#untero en una e7#resin relacional, usando o#eraciones
relacionales de igualdad =P P>, desigualdad =YP> y com#aracin =E,
F, PE, FP>.

%a aritm3tica de #unteros, tiene sentido slo cuando el #untero #osee
asignado varias direcciones continuas de memoria, es decir, cuando se ejecuta
sobre un arreglo. &s muy #oco #robable que dos variables de un mismo ti#o de
datos #osean direcciones contiguas de memoria a no ser que sean elementos
adyacentes que +ormen #arte de un arreglo.

&7em4lo

# include <stdio.h>
void main()
{
int *px, *py;
static int a[6]= { 1, 2, 3, 4, 5, 6];
px=&a[0]:
py=&a[5]:

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $$

printf (px=%x py%x, px, py);
printf (\n\npy- px=%x, py - px);
}

La ejecucin del programa produce la siguientes salida:
px=52 py=5c
py px=5

Relaci6n entre rreglos y (unteros

%os nombres de los arreglos, son un ti#o es#ecial de #unteros, que a#untan
a la direccin de memoria del #rimer elemento del arreglo. Recordemos que los
arreglos #oseen elementos almacenados en direcciones contiguas de memoria.
Cada elemento del arreglo #osee una direccin de memoria.

&7em4lo:

int v[10] = {0,1,2,3,4,5,6,7,8,9,};
int *ptrv;
ptrv = &v[0]; //se le asigna al puntero ptrv, la direccin de memoria del primer elemento del
arreglo v;
//equivale a ptrv = v;
ptrv = v; //se asigna la direccin de v a ptrv.

Como dijimos anteriormente, el nombre del arreglo =v> es un #untero, que
a#unta, a la #rimera direccin de memoria del arreglo. -or lo tanto se est.
reali$ando una asignacin de #unteros. Cualquier #osicin de un elemento en el
arreglo se #uede obtener con el o#erador de direccin.
#trv P VvA4B< NN#trv a#unta a la #osicin 4 del arreglo.
#trv P VvAIB< NN#trv a#unta a la #osicin I del arreglo.

Con aritm3tica de #unteros, es #osible acceder a la direccin de cada
elemento del arreglo.

&7em4lo:

int v[10] = {0,1,2,3,4,5,6,7,8,9,};
int *ptrv;
ptrv = &v[0];// equivale a ptrv=v;
//Aritmtica
ptrv + 2; //equivale a &v[2]
ptrv + 6; //equivale a &v[6]


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina $/

&n ambos casos, #trv no modi+ica la direccin de memoria a la que
a#unta.
&n la aritm3tica de #unteros la sumatoria de enteros a memorias =#trv W n>
se reali$a en base a la cantidad de bytes del ti#o de datos del #untero =#trv W nS
tJbytes>.

!i4os 3atos !ama@o 5yte =m'9uina ,) bits> !ama@o 5yte =m'9uina 2- bits>
c6ar 1 byte 1 byte
int ( bytes 4 bytes
long 4 bytes 4 bytes
+loat 4 bytes 4 bytes

'i el arreglo es de ti#o int, cada #osicin del arreglo ocu#a ( bytes de
memoria =m.quinas de 1M bits>, #or lo tanto avan$a =#trv W =( S (>>

&n el siguiente ejem#lo se inicia en la #rimera #osicin

int *ptrv, v[3] = {15, 18, 20, 46};

ptrv = v;//ptrv apunta a la direccin 2000

printf(%d, *ptrv); //valor 15
ptrv = ptrv + 1;//avanza a la posicin de direccin 2002
//ptrv = 2000 + (1 * 2) = 2000 + 2 = 2002
ptrv+=2; //avanza a la posicin de direccin 2006
//ptrv = 2000 + (2 * 2) = 2000 + 4 = 2006

Resumen de las O4eraciones con (unteros

1. A una variable #untero se le #uede asignar la direccin de memoria
de una variable ordinaria =#vPV#>.
(. A una variable #untero se le #uede asignar el valor de otra variable
#untero =#vP#y>, siem#re y cuando ambos #unteros a#unten al
1 5 1 8 2 0 4 6
200 200
200 200 200
200
200 200 200


mismo ti#o de datos o que el #untero #v sea un #untero gen3rico
=#untero a void>.
1. A una variable #untero se le #uede asignar un valor nulo =cero>
=#vP2!%%, 2!%% es una constante simblica con valor cero>.
4. !na cantidad entera #uede ser sumada o restada a una variable
#untero =#7W1, #vWW>.
5. !na variable #untero #uede ser restada de otra siem#re y cuando
ambas a#unten a elementos del mismo arreglo.
M. *os variables #unteros #ueden ser com#aradas siem#re que ambas
a#unten a datos del mismo ti#o de datos.

(unteros y Funciones

!n .rea en la cual desem#e:an un #a#el #rominente los a#untadores, en
el lenguaje C, es en la transmisin de #ar.metros a +unciones. -or lo comn, los
#ar.metros se transmiten #or valor a una +uncin en C, es decir, se co#ian los
valores transmitidos en los #ar.metros de la +uncin llamada en el momento en
que se invoca. 'i cambia el valor de un #ar.metro dentro de la +uncin, no
cambia su valor en el #rograma que la llama. -or ejem#lo consid3rese el siguiente
+ragmento8
...
X=5;
printf (%d\n, x);
funct(x);
printf(%d\n, x);
...

void funct (int y)
{
++y;
printf(%d\n,y);
return;
}
%a ejecucin del #rograma ser;a8 im#rime el nmero 5 y des#u3s llama a
+unct. &l valor de G7G, que es 5, se co#ia en GyG y comien$a la ejecucin de +unct.
*es#u3s, im#rime el nmero M y regresa +unct. 'in embargo, cuando se


incrementa el valor de GyG, el valor de G7G #ermanece invariable. As;, im#rime el
nmero 5, G7G y GyG re+ieren a ( variables di+erentes.
'i deseamos usar +unct #ara modi+icar el valor de G7G, debemos de transmitir
la direccin de G7G de la siguiente manera8
...
X=5;
printf (%d\n, x);
funct(&x);
printf(%d\n, x);
...

void funct (int *py)
{
++(*py);
printf(%d\n, *py);
return;
}
%a ejecucin del #rograma ser;a8 Im#rime nuevamente el nmero 5, y la
l;nea 4 llama a +unct. A6ora, sin embargo, el valor trans+erido no es el valor entero
de G7G sino el valor a#untador GV7G. &ste es la direccin de G7G. &l #ar.metro de
+unct no es m.s y de ti#o int, sino #y de ti#o int S . =&s conveniente nombrar a las
variables a#untadores comen$ando con la letra # #ara recordar tanto que se
trata de un a#untador> la l;nea C a6ora aumenta al entero en la localidad #y< #y,
sin embargo, no cambia y conserva su valor inicial GV7G. As;, #y a#unta al entero
G7G de tal manera que cuando S#y, aumenta 7. %uego se im#rime M y cuando
regresa +unct, im#rime tambi3n M. %os a#untadores son el mecanismo usado en el
lenguaje C #ara #ermitir a una +uncin llamada modi+icar las variables de la
+uncin que llama.
(recauciones con los 4untadores

4untadores No Iniciali%ados:

'i se altera el valor al que a#unta un #untero no iniciali$ado, se
estar. modi+icando cualquier #osicin de la memoria.



main()
{
int* puntero;
*puntero = 1200; /* Se machaca una zona cualquiera de la memoria */
}

Con#usi6n 3e !i4os:

!n #untero a un ti#o determinado #uede a#untar a una variable de
cualquier otro ti#o. Aunque el com#ilador lo #uede advertir, no es un error.
=A+ortunadamente, esto no ocurre en CWW>.

main()
{
int p;
double numero;
int* puntero;

p = &numero; /* incorrecto,
pero el compilador no aborta */
*p = 33; /* Un desastre */
}

4untadores a variables locales #uera de 'mbito:

'i un #untero a#unta a una variable local, cuando la variable
desa#are$ca el #untero a#untar. a una $ona de memoria que se estar.
usando #ara otros +ines. 'i se des-re+erencia el #untero, los resultados son
im#revisibles y a menudo catastr+icos.

main()
{
int* puntero;

while (...)
{
int local;
puntero = &local;
/* puntero apunta a una variable local */
...
*puntero = 33; /* correcto */
}
...

/* ahora puntero apunta a una zona de memoria
invlida */

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina /3

puntero = 50; /* catstrofe */
}

%b&eti'o #)* 5structuras

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina /(

&l uso de estructuras como una re#resentacin o a#ro7imacin de
registros de datos, 6a sido una de las 6erramientas m.s idneas usada en
la -rogramacin &structurada #ara #oder agru#ar varios ti#os de datos
#rimitivos en un solo a la +inal.


Conce4tos 5'sicos
cceso a los com4onentes de una estructura.
rreglos de &structuras
&structuras nidadas
4untadores a estructuras.
(aso de estructuras a las #unciones.



Conce4tos 5'sicos
"na &structura es una coleccin de variables sim#les, que #ueden contener
di+erentes ti#os de datos. &s un ti#o de dato de+inido #or el usuario. 'on tambi3n
conocidas como Registros.
Ayudan a organi$ar y manejar datos com#licados en #rogramas debido a
que agru#an di+erentes ti#os de datos a las que se les trata como una sola
unidad en lugar de ser vistas como unidades se#aradas.
&n C se +orma una estructura utili$ando la #alabra reservada struct, seguida
#or un cam#o etiqueta o#cional, y luego una lista de miembros dentro de la
estructura. %a etiqueta o#cional se utili$a #ara crear otras variables del ti#o
#articular de la estructura8
struct campo_etiqueta{
tipo_miembro miembro_1;
:
:
tipo_miembro miembro_n;
};
!n #unto y coma +inali$a la de+inicin de una estructura #uesto que 3sta es
realmente una sentencia C. Algunos de los ejem#los usan la estructura8
struct stbarco{
char tipo[15];
char modelo[15];
char titular[20];
int anno;
long int horas_motor;
float precioventa;
};
&n un #rograma, #odemos asociar una variable con una estructura
utili$ando una sentencia similar a la siguiente8
struct stbarco stbarco_usado;

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina /"

%a sentencia de+ine stbarcoJusado de ti#o struct stbarco. %a declaracin
requiere el uso del cam#o etiqueta de la estructura. 'i esta sentencia est.
contenida dentro de una +uncin, entonces la estructura, llamada stbarcoJusado,
tiene un .mbito local a esa +uncin. 'i la sentencia est. contenida +uera de todas
las +unciones de #rograma, la estructura tendr. un .mbito global. &s #osible
declarar una variable usando esta sinta7is8
struct stbarco{
char tipo[15];
char modelo[15];
char titular[20];
int anno;
float precioventa;
};stbarco_usado;
Aqu; la declaracin de variable va antes del #unto y coma +inal. Cuando
se asocia slo una variable con el ti#o estructura, el cam#o etiqueta #uede ser
eliminado, #or lo que ser;a #osible escribir8
struct {
char tipo[15];
char modelo[15];
char titular[20];
int anno;
float precioventa;
};stbarco_usado;

cceso a los Com4onentes de una &structura
-ara accesar a los miembros de las estructuras se usa el #unto u o#erador
miembro =.>. %a sinta7is es8
estructuraNombre.miembroNombre
-or ejem#lo en8
gets(stbarco_usado.modelo);
Aqu;, stbarcoJusado es el nombre asociado con la estructura, y modelo es
una variable miembro de la estructura, otro ejem#lo8

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina /#

gets(stbarco_usado.tipo);
&sta sentencia leer. la marca del stbarcoJusado en el arreglo de
caracteres, mientras la #r7ima sentencia im#rimir. el #recio de venta de
stbarcoJusado en la #antalla.
printf(%f, stbarco_usado.precioventa);
&jem#lo de estructuras8
#include <stdio.h>
#include <conio.h>
struct datos
{
char num_control[9];
char nombre[30];
int edad;
char sexo;
char domicilio[30];
};

struct datos alumno;
void main ( )
{
clrscr( );
printf(\nIntroduce los datos del alumno:);
printf(\nNmero de Control:);
gets(alumno.num_control);
printf(\nNombre:);
gets(alumno.nombre);
printf(\nEdad:);
scanf(%d,&alumno.edad);
printf(\nSexo:);
alumno.sexo=getchar( );
printf(\nDireccin:);
gets(alumno.domicilio);
printf(\nLos datos capturados fueron:);
printf(\nNmero de Control:);
puts(alumno.num_control);
printf(\nNombre:);
puts(alumno.nombre);
printf(\nEdad:);
printnf(%d,alumno.edad);
printf(\nSexo:);
putchar(alumno.sexo);
printf(\nDireccin:);
puts(alumno.domicilio);
getch ( );
}


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina /$

rreglos de &structuras
-ueden ser construidas, es decir, conce#tuar a los elementos de un arreglo
como estructuras, esto se #uede 6acer de la siguiente manera8
struct datos
{
char num_control[9];
char nombre[30];
int edad;
char sexo;
char domicilio[30];
};

struct datos alumnos[35]; /*Esta es la variable arreglo de estructura*/

-ara tener acceso a una determinada estructura, se inde7a el nombre de
la estructura de la siguiente manera8 alumnosAiB.nombre< aqu; sabemos el nombre
del alumno que se encuentra en la #osicin i del arreglo, y de esta manera #ara
todos los datos.
&structuras nidadas
!na estructura #uede contener otras estructuras llamadas estructuras
anidadas. %as estructuras anidadas a6orran tiem#o en la escritura de #rogramas
que utili$an estructuras similares. 'e 6an de de+inir los miembros comunes solo una
ve$ en su #ro#ia estructura y a continuacin utili$ar es estructura como un
miembro de estructura. Consideremos las siguientes dos de+iniciones de
estructuras8
struct empleado
{
char nombre_emp[30];
char direccion[25];
char ciudad[20];
char provincia[20];
long int cod_postal;
double salario;
};

struct clientes
{

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina //

char nombre_cliente[30];
char direccion[25];
char ciudad[20];
char provincia[20];
double saldo;
};

&stas estructuras contienen muc6os datos di+erentes, aunque 6ay
datos que est.n sola#ados. As;, se #odr;a dis#oner de una estructura,
info_dir que contuviera los miembros comunes.
struct info_dir
{
char direccion[25];
char ciudad[20];
char provincia[20];
};
&sta estructura se #uede utili$ar como miembro de las otras
estructuras, es decir anidarse.

struct empleado
{
char nombre_emp[30];
struct info_dir direccion_emp;
double salario;
};

struct clientes
{
char nombre_cliente[30];
struct info_dir direccion_clien;
double saldo;
};

4untadores a &structuras

!n #untero tambi3n #uede a#untarse a una estructura. 'e #uede
declarar un #untero a una estructura tal como se declara un #untero a
cualquier otro objeto y se declara un #untero estructura tal como se
declara cualquier otra variable estructura8 es#eci+icando un #untero en
lugar del nombre de la variable estructura.
struct persona
{


char nombre[30];
int edad;
int altura;
int peso;
};
struct persona empleado;
struct persona persona *p;
p = &empleado;

Cuando se re+erencia un miembro de la estructura utili$ando el
nombre de la estructura, se es#eci+ica la estructura y el nombre del
miembro se#arado #or un #unto =.>. -ara re+erenciar el nombre de una
#ersona, utilice empleado.nombre. 'e re+erencia una estructura utili$ando el
#untero estructura. 'e utili$a el o#erador -> #ara acceder a un miembro de
ella.

(aso de &structuras a las Funciones

C #ermite #asar estructuras a +unciones, bien #or valor o bien #or
re+erencia utili$ando el o#erador V. 'i la estructura es grande, el tiem#o
necesario #ara co#iar un #ar.metro struct a la #ila #uede ser #ro6ibitivo.

&n tales casos, se debe considerar el m3todo de #asar la direccin
de la estructura. &l siguiente #rograma muestra el #ase de la direccin de
una estructura a una +uncin #ara entrada de datos.

%a misma variable la #asa #or valor a otra +uncin #ara salida de los
cam#os.
#include <stdio.h>
/*Define el tipo de estructura info_persona*/
struct info_persona
{
char nombre[30];
char calle[30];
char ciudad[25];
char provincia[25];
char codigopostal[6];
};
/*Prototipos de funciones*/


void entrad_pna(struct info_persona *pp);
void ver_info(struct info_persona p);
void main ( )
{
struct info_persona reg_dat;
entrad_pna(&reg_dat); /*Pasa por referencia la variable*/
ver_info(reg_dat); /*Pasa por valor*/
clrscr( );
printf(\nPulsa cualquier carcter para continuar\n);
getchar( );

}
void entrad_pna (struct info_persona *pp)
{
clrscr( );
puts(\nEntrada de datos de la Persona\n);
/*Para acceder a los campos se utiliza el selector -> */
printf(\nNombre:);
gets(pp->nombre);
printf(\nCalle:);
gets(pp->calle);
printf(\nCiudad:);
gets(pp->ciudad);
printf(\nProvincia:);
gets(pp->provincia);
printf(\nCdigo Postal:);
gets(pp->codigopostal);
}
void ver_info (struct info_persona p)
{
clrscr( );
puts(\n\t Informacin relativa a la persona);
puts(p.nombre);
puts(p.calle);
puts(p.ciudad);
puts(p.provincia);
puts(p.codigopostal);
}
%b&eti'o $)* Arc6i'os


%os arc6ivos en total inde#endencia con el lenguaje de #rogramacin que
se trabaje siem#re 6an servido #ara #oder almacenar en +orma #ermanente
datos yNo registros indis#ensables #ara transacciones de#endiendo de la
organi$acin que la amerite en su determinado momento.


Conce4tos 5'sicos
!i4os de arcNivos
rcNivos de !eFto. O4eraciones 9ue se reali%an sobre ellos.
rcNivos 5inarios. O4eraciones 9ue se reali%an sobre ellos.
&7em4los de (rogramas de rcNivos y mani4ulaci6n



Conce4tos 5'sicos
*urante la 6istoria de los com#utadores se 6an usado varios m3todos
distintos #ara el almacenamiento de datos. Al #rinci#io se recurri a cintas de
#a#el #er+oradas, des#u3s a tarjetas #er+oradas. A continuacin se #as al
so#orte magn3tico, em#e$ando #or grandes rollos de cintas magn3ticas abiertas.
Oasta aqu;, todos los sistemas de almacenamiento e7terno eran
secuenciales, es decir, no #ermit;an acceder al #unto e7acto donde se guardaba
la in+ormacin sin antes 6aber #artido desde el #rinci#io y sin 6aber le;do toda la
in+ormacin, 6asta el #unto donde se encontraba lo que est.bamos buscando.
Con las cintas magn3ticas em#e$ lo que con el tiem#o ser;a el acceso
aleatorio a los datos. 'e #od;a reservar #arte de la cinta #ara guardar cierta
in+ormacin sobre la situacin de los datos, y a:adir ciertas marcas que 6icieran
m.s sencillo locali$arla.
-ero no +ue 6asta la a#aricin de los discos magn3ticos cuando 3sta
t3cnica lleg a su sentido m.s am#lio. &n los discos es m.s sencillo acceder a
cualquier #unto de la su#er+icie en #oco tiem#o, ya que se accede al #unto de
lectura y escritura usando dos coordenadas +;sicas. -or una #arte la cabe$a de
lecturaNescritura se #uede mover en el sentido del radio del disco, y #or otra el
disco gira #ermanentemente, con lo que cualquier #unto del disco #asa #or la
cabe$a en un tiem#o relativamente corto. &sto no #asa con las cintas, donde slo
6ay una coordenada +;sica.
Con la invencin y #roli+eracin de los discos se desarrollaron los arc6ivos o
arc6ivos de acceso aleatorio, que #ermiten acceder a cualquier dato
almacenado en un arc6ivo en relativamente #oco tiem#o.
Actualmente, los discos duros tienen una enorme ca#acidad y son muy
r.#idos, aunque an siguen siendo lentos, en com#aracin con las memorias
RA". &l caso de los C* es algo intermedio. &n realidad son secuenciales en

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 0(

cuanto al modo de guardar los datos, cada disco slo tiene una #ista de datos
grabada en es#iral. 'in embargo, este sistema, combinado con algo de memoria
RA", #ro#orciona un acceso muy #r7imo al de los discos duros.
%os datos que 6emos tratado 6asta el momento 6an residido en la
memoria #rinci#al. 'in embargo, las grandes cantidades de datos se almacenan
normalmente en un dis#ositivo de memoria secundaria.
&stas colecciones de datos se conocen como arc6ivos. "n arcNivo es un
conjunto de datos estructurados en una coleccin de entidades elementales o
b.sicas denominadas registros que son de igual ti#o y constan a su ve$ de
di+erentes entidades de nivel m.s bajos denominadas cam#os.
!i4os de rcNivos
1. ependiendo de la direccin del flu!o de datos"
o e entrada" los datos se leen #or el #rograma desde el arc6ivo.
o e salida" los datos se escriben #or el #rograma 6acia el arc6ivo.
o e entrada#salida" los datos #ueden ser escritos o le;dos.
$. ependiendo del tipo de valores permitidos a cada b%te"
o e texto" slo est.n #ermitidos ciertos rangos de valores #ara cada
byte. Algunos bytes tienen un signi+icado es#ecial, #or ejem#lo, el
valor 6e7adecimal @71A marca el +in de arc6ivo. 'i abrimos un
arc6ivo en modo te7to, no ser. #osible leer m.s all. de un byte con
ese valor, aunque el arc6ivo sea m.s largo.
o &inarios" est.n #ermitidos todos los valores #ara cada byte. &n estos
arc6ivos el +inal del arc6ivo se detecta de otro modo, de#endiendo
del so#orte y del sistema o#erativo. %a mayor;a de las veces se 6ace
guardando la longitud del arc6ivo. Cuando queramos almacenar
valores enteros, o en coma +lotante, o im.genes, etc., deberemos
usar este ti#o de arc6ivos.



'. (e)*n el tipo de acceso"
o +rchivos secuenciales" imitan el modo de acceso de los antiguos
arc6ivos secuenciales almacenados en cintas magn3ticas y
o +rchivos de acceso aleatorio" #ermiten acceder a cualquier #unto
de ellos #ara reali$ar lecturas yNo escrituras.
,. (e)*n la lon)itud de re)istro"
o Lon)itud variable" en realidad, en este ti#o de arc6ivos no tiene
sentido 6ablar de longitud de registro, #odemos considerar cada
byte como un registro. ,ambi3n #uede suceder que nuestra
a#licacin cono$ca el ti#o y longitud de cada dato almacenado en
el arc6ivo, y lea o escriba los bytes necesarios en cada ocasin. Otro
caso es cuando se usa una marca #ara el +inal de registro, #or
ejem#lo, en arc6ivos de te7to se usa el car.cter de retorno de l;nea
#ara eso. &n estos casos cada registro es de longitud di+erente.
o Lon)itud constante" en estos arc6ivos los datos se almacenan en
+orma de registro de tama:o contante. &n C usaremos estructuras
#ara de+inir los registros. C dis#one de +unciones de librer;a
adecuadas #ara manejar este ti#o de arc6ivos.
o -ixtos" en ocasiones #ueden crearse arc6ivos que combinen los dos
ti#os de registros, #or ejem#lo, dBA'& usa registros de longitud
constante, #ero a:ade un registro es#ecial de cabecera al #rinci#io
#ara de+inir, entre otras cosas, el tama:o y el ti#o de los registros.
&s #osible crear arc6ivos combinando cada una de estas categor;as, #or
ejem#lo8 arc6ivos secuenciales de te7to de longitud de registro variable, que son
los t;#icos arc6ivos de te7to. Arc6ivos de acceso aleatorio binarios de longitud de
registro constante, normalmente usados en bases de datos. Z tambi3n cualquier
combinacin menos corriente, como arc6ivos secuenciales binarios de longitud
de registro constante, etc.
&n cuanto a cmo se de+inen estas #ro#iedades, 6ay dos casos8 'i son
binarios o de te7to o de entrada, salida o entradaNsalida,

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 0"

!n Flu7o =Stream>, no es m.s que una abstraccin que se re+iere a una
corriente de datos que +luyen entre un origen o +uente =4roductor> y un destino o
sumidero =consumidor>, entre el origen y el destino debe e7istir una cone7in o
canal =4i4e> #or la que circulen los datos. %a a#ertura de un arc6ivo su#one
establecer la cone7in del #rograma con el dis#ositivo que contiene el arc6ivo,
#or el canal que comunica el arc6ivo con el #rograma van a +luir las secuencias
de datos. Oay tres +lujos o canales abiertos autom.ticamente8
eFtern FIL& EstdinL
eFtern FIL& EstdoutL
eFtern FIL& EstderrL
&stas tres variables se iniciali$an al comen$ar la ejecucin del #rograma
#ara admitir secuencias de caracteres, en modo te7to. 'u contenido es el
siguiente8
stdin asocia la entrada est.ndar =teclado> con el #rograma.
stdout asocia la salida est.ndar =#antalla> con el #rograma.
stderr asocia la salida de mensajes de error =#antalla> con el
#rograma.
Asi cuando se ejecuta #rint+=[Calle "ayor (.\>< se escribe en stdout, en
#antalla< si se desea leer una variable entera con scan+=[Ud\,V7>< se ca#tan los
d;gitos de la secuencia de entrada stdin. &l acceso a arc6ivos se 6ace con un
bu++er intermedio. 'e #uede #ensar en el bu++er como un array donde se van
almacenando los datos dirigidos al arc6ivo, o desde el arc6ivo< el bu++er se vuelca
cuando de una +orma u otra se da la orden de vaciarlo. -or ejem#lo, cuando se
llama a una +uncin #ara leer del arc6ivo una cadena, la +uncin lee tantos
caracteres como que#an en el bu++er. A continuacin se obtiene la cadena del
bu++er< una #osterior llamada a la +uncin obtendr. la siguiente cadena del bu++er

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 0#

y as; sucesivamente 6asta que quede vac;o y se llene con una llamada #osterior
a la +uncin de lectura. &l C trabaja con arc6ivos con bu++er, y est. dise:ado #ara
acceder a una am#lia gama de dis#ositivos, de tal +orma que trata cada
dis#ositivo como una secuencia, #udiendo 6aber secuencias de caracteres y
secuencias binarias. Con las secuencias se sim#li+ica el manejo de arc6ivos en C.
&n el #rograma el arc6ivo tiene un nombre interno que es un #untero a una
estructura #rede+inida =#untero a arc6ivo>. &sta estructura contiene la in+ormacin
sobre el arc6ivo, tal como la direccin del bu++er que utili$a, el modo de a#ertura
del arc6ivo, el ltimo car.cter le;do del bu++er y otros detalles que generalmente
el usuario no necesita saber. &l identi+icador del ti#o de la estructura es FIL& y est.
declarada en el arc6ivo de cabecera stdio.6
&7em4lo:
FILE *pf;

4ertura de un arcNivo
SintaFis:
FILE *fopen(char *nombre, char *modo);
&sta +uncin sirve #ara abrir y crear arc6ivos en disco. &l valor de retorno es un
#untero a una estructura )I%&. %os #ar.metros de entrada son8
1. nombre" una cadena que contiene un nombre de arc6ivo v.lido, esto
de#ende del sistema o#erativo que estemos usando. &l nombre #uede
incluir el camino com#leto.
(. modo" es#eci+ica en ti#o de arc6ivo que se abrir. o se crear. y el ti#o de
datos que #uede contener, de te7to o binarios8
o r" slo lectura. &l arc6ivo debe e7istir.
o ." se abre #ara escritura, se crea un arc6ivo nuevo o se sobrescribe
si ya e7iste.

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 0$

o a" a:adir, se abre #ara escritura, el cursor se sita al +inal del arc6ivo.
'i el arc6ivo no e7iste, se crea.
o r/" lectura y escritura. &l arc6ivo debe e7istir.
o ./" lectura y escritura, se crea un arc6ivo nuevo o se sobrescribe si
ya e7iste.
o a/" a:adir, lectura y escritura, el cursor se sita al +inal del arc6ivo. 'i
el arc6ivo no e7iste, se crea.
o t" ti#o te7to, si no se es#eci+ica GtG ni GbG, se asume #or de+ecto que es
GtG
o b" ti#o binario.
&7em4lo:
FILE *archivo;
archivo = fopen("ejemplo1.c", "r");

Clausura de un arcNivo
SintaFis:
int fclose(FILE *archivo);
&s im#ortante cerrar los arc6ivos abiertos antes de abandonar la
a#licacin. &sta +uncin sirve #ara eso. Cerrar un arc6ivo almacena los datos que
an est.n en el bu++er de memoria, y actuali$a algunos datos de la cabecera del
arc6ivo que mantiene el sistema o#erativo.
Adem.s #ermite que otros #rogramas #uedan abrir el arc6ivo #ara su uso.
"uy a menudo, los arc6ivos no #ueden ser com#artidos #or varios #rogramas.
!n valor de retorno cero indica que el arc6ivo 6a sido correctamente
cerrado, si 6a 6abido algn error, el valor de retorno es la constante &O). &l
#ar.metro es un #untero a la estructura )I%& del arc6ivo que queremos cerrar.


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 0/

&7em4lo:
fclose(archivo);
N"LL y &OF
%as +unciones de biblioteca que devuelvan un #untero =strc#y=>, +o#en=>?>
es#eci+ican que si no #ueden reali$ar la o#eracin =generalmente si 6ay un error>
devuelven N"LL. &sta es una macro de+inida en varios arc6ivos de cabecera,
entre los que se encuentran stdio.6 y stdlib.6. %as +unciones de librer;a de &N' de
arc6ivos generalmente em#ie$an #or + de +ile, tienen es#eci+icado que son de
ti#o entero de tal +orma que si la o#eracin +alla devuelven &OF, tambi3n
devuelven &OF #ara indicar que se 6a le;do el +in de arc6ivo.
&sta macro est. de+inida en stdio.6

rcNivos de !eFto
"n arcNivo de teFto es una secuencia de caracteres organi$adas en l;neas
terminadas #or un car.cter de nueva l;nea. &n estos arc6ivos se #ueden
almacenar canciones, +uentes de #rogramas, base de datos sim#les, etc. %os
arc6ivos de te7to se caracteri$an #or ser #lanos, es decir, todas las letras tienen el
mismo +ormato y no 6ay #alabras subrayadas, en negrita, o letras de distinto
tama:o o anc6o. !na ve$ abierto el arc6ivo #ara escribir datos 6ay que grabar
los datos en el arc6ivo. %a biblioteca C #ro#orciona diversas +unciones #ara
escribir datos en el arc6ivo a trav3s del #untero a )I%& asociado. %as +unciones de
entrada y salida de arc6ivos tienen muc6o #arecido a las +unciones utili$adas
#ara entrada y salida de +lujos stdin =teclado> y stdout =#antalla>< #rint+=>, scan+=>,
getc6ar=>, #utc6ar=>, gets=> y #uts=>. ,odas tienen una versin #ara arc6ivos que
em#ie$a #or la letra +, as; se tiene +#rint+=>, +scan+=>, +#uts=>, +gets=>< la mayor;a de
las +unciones es#ec;+icas de arc6ivos em#ie$an #or +.



Funciones 4utc=> y #4utc=>
SintaFis
putc(int caracter, FILE *archivo);

fputc(int caracter, FILE *archivo);
&stas +unciones escriben un car.cter a un arc6ivo. &l valor de retorno es el
car.cter escrito, si la o#eracin +ue com#letada con 37ito, en caso contrario ser.
&O). %os #ar.metros de entrada son el car.cter a escribir, convertido a int y un
#untero a una estructura )I%& del arc6ivo en el que se 6ar. la escritura.
Funciones getc=> y #getc=>
SintaFis
getc( FILE *archivo);

fgetc(FILE *archivo);
&stas +unciones leen un car.cter desde un arc6ivo. &l valor de retorno es el
car.cter le;do como un unsigned c6ar convertido a int. 'i no 6ay ningn car.cter
dis#onible, el valor de retorno es &O). &l #ar.metro es un #untero a una estructura
)I%& del arc6ivo del que se 6ar. la lectura.
Funciones #4uts=> y #gets=>
SintaFis
fputs(const char *cadena, FILE *archivo);

fgetc(const char *cadena, int n, FILE *archivo);
%a +uncin #4uts escribe una cadena en un arc6ivo. 2o se a:ade el
car.cter de retorno de l;nea ni el car.cter nulo +inal.


&l valor de retorno es un nmero no negativo o &O) en caso de error. %os
#ar.metros de entrada son la cadena a escribir y un #untero a la estructura )I%&
del arc6ivo donde se reali$ar. la escritura.
%a +uncin #gets est. dise:ada #ara leer cadenas de caracteres. %eer.
6asta n-1 caracteres o 6asta que lea un retorno de l;nea. &n este ltimo caso, el
car.cter de retorno de l;nea tambi3n es le;do.
&l #ar.metro n nos #ermite limitar la lectura #ara evitar desbordar el
es#acio dis#onible en la cadena.
&l valor de retorno es un #untero a la cadena le;da, si se ley con 37ito, y es
2!%% si se detecta el +inal del arc6ivo o si 6ay un error. %os #ar.metros son8 la
cadena a leer, el nmero de caracteres m.7imo a leer y un #untero a una
estructura )I%& del arc6ivo del que se leer..
Funciones #4rint#=> y #scan#=>
SintaFis
int fprintf(FILE *archivo, const char *formato, ...);

int fscanf(FILE *archivo, const char *formato, ...);

%a +uncin #4rint# +unciona igual que #rint+ en cuanto a #ar.metros, #ero la
salida se dirige a un arc6ivo en lugar de a la #antalla.
%a +uncin #scan# +unciona igual que scan+ en cuanto a #ar.metros, #ero la
entrada se toma de un arc6ivo en lugar del teclado.



Funci6n #eo#=>
SintaFis
int feof(FILE *archivo);

&sta +uncin sirve #ara com#robar si se 6a alcan$ado el +inal del arc6ivo.
"uy +recuentemente deberemos trabajar con todos los valores almacenados en
un arc6ivo de +orma secuencial, la +orma que suelen tener los bucles #ara leer
todos los datos de un arc6ivo es #ermanecer leyendo mientras no se detecte el
+in de arc6ivo. &sta +uncin suele usarse como #rueba #ara veri+icar si se 6a
alcan$ado o no ese #unto.
&l valor de retorno es distinto de cero slo si no se 6a alcan$ado el +in de
arc6ivo. &l #ar.metro es un #untero a la estructura )I%& del arc6ivo que queremos
veri+icar.

Funci6n reRind=>
SintaFis
void rewind(FILE *archivo)

&s una +uncin 6eredada de los tiem#os de las cintas magn3ticas.
%iteralmente signi+ica GrebobinarG, y 6ace re+erencia a que #ara volver al #rinci#io
de un arc6ivo almacenado en cinta, 6ab;a que rebobinarla. &so es lo que 6ace
3sta +uncin, sita el cursor de lecturaNescritura al #rinci#io del arc6ivo.
&l #ar.metro es un #untero a la estructura )I%& del arc6ivo que queremos
rebobinar.



rcNivos 5inarios

!n arc6ivo binario es una secuencia de bytes que tienen una
corres#ondencia uno a uno con un dis#ositivo e7terno. As; que no tendr. lugar
ninguna traduccin de caracteres. Adem.s, el nmero de bytes escritos =le;dos>
ser. el mismo que los encontrados en el dis#ositivo e7terno. &jem#los de estos
arc6ivos son )otogra+;as, im.genes, te7to con +ormatos, arc6ivos ejecutables
=a#licaciones>, etc.

Funci6n de Salida #Rrite=>
SintaFis
fwrite(void *puntero, size_t tamao, size_t nregistros, FILE *archivo);

&sta +uncin tambi3n est. #ensada #ara trabajar con registros de longitud
constante y +orma #areja con +read. &s ca#a$ de escribir 6acia un arc6ivo uno o
varios registros de la misma longitud almacenados a #artir de una direccin de
memoria determinada.
&l valor de retorno es el nmero de registros escritos, no el nmero de bytes.
%os #ar.metros son8 un #untero a la $ona de memoria donde se almacenar.n los
datos le;dos, el tama:o de cada registro, el nmero de registros a leer y un
#untero a la estructura )I%& del arc6ivo del que se 6ar. la lectura.
Funci6n de &ntrada #read=>
SintaFis
fread(void *puntero, size_t tamao, size_t nregistros, FILE *archivo);
&sta +uncin est. #ensada #ara trabajar con registros de longitud
constante. &s ca#a$ de leer desde un arc6ivo uno o varios registros de la misma

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 1(

longitud y a #artir de una direccin de memoria determinada. &l usuario es
res#onsable de asegurarse de que 6ay es#acio su+iciente #ara contener la
in+ormacin le;da.
&l valor de retorno es el nmero de registros le;dos, no el nmero de bytes.
%os #ar.metros son8 un #untero a la $ona de memoria donde se almacenar.n los
datos le;dos, el tama:o de cada registro, el nmero de registros a leer y un
#untero a la estructura )I%& del arc6ivo del que se 6ar. la lectura.

Funciones 4ara el acceso aleatorio
&l acceso directo X aleatorio X a los datos de un arc6ivo se 6ace mediante
su #osicin, es decir, el lugar relativo que ocu#an. ,iene la ventaja de que se
#ueden leer y escribir registros en cualquier orden y #osicin. 'on muy r.#idos de
acceso a la in+ormacin que contienen.
&l #rinci#al inconveniente que tiene la organi$acin directa es que
necesita #rogramar la relacin e7istente entre el contenido de un registro y la
#osicin que ocu#an. %as +unciones #seek=> y #tell=> se usan #rinci#almente #ara el
acceso directo a arc6ivos en C. Hstas consideran el arc6ivo como una secuencia
de bytes< el nmero de bytes es el ;ndice del arc6ivo. 'egn se va leyendo o
escribiendo registros o datos en el arc6ivo, el #rograma mantiene a trav3s de un
#untero la #osicin actual. Con la llamada a la +uncin +tell=> se obtiene el valor
de dic6a #osicin. %a +uncin +see]=> #ermite cambiar la #osicin del #untero a
arc6ivo a una direccin determinada.



Funci6n #seek=>
SintaFis
fseek(FILE *archivo, long int desplazamiento, int origen);

&sta +uncin sirve #ara situar el cursor del arc6ivo #ara leer o escribir en el
lugar deseado. &l valor de retorno es cero si la +uncin tuvo 37ito, y un valor
distinto de cero si 6ubo algn error. %os #ar.metros de entrada son8 un #untero a
una estructura )I%& del arc6ivo en el que queremos cambiar el cursor de
lecturaNescritura, el valor del des#la$amiento y el #unto de origen desde el que se
calcular. el des#la$amiento. &l #ar.metro origen #uede tener tres #osibles
valores8
(EE01(E2 el des#la$amiento se cuenta desde el #rinci#io del arc6ivo. &l
#rimer byte del arc6ivo tiene un des#la$amiento cero.
(EE01345 el des#la$amiento se cuenta desde la #osicin actual del cursor.
(EE01E6 el des#la$amiento se cuenta desde el +inal del arc6ivo.
Funci6n #tell=>
SintaFis
ftell(FILE *archivo);

%a +uncin #tell sirve #ara averiguar la #osicin actual del cursor de
lecturaNescritura de un arc6ivo. &l valor de retorno ser. esa #osicin, o -1 si 6ay
algn error. &l #ar.metro de entrada es un #untero a una estructura )I%& del
arc6ivo del que queremos leer la #osicin del cursor de lecturaNescritura.


Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 1"

&7em4lo

// alea.c: Ejemplo de ficheros de acceso aleatorio.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>

struct stRegistro {
char valido; // Campo que indica si el registro es vlido S->Vlido,
N->Invlido
char nombre[34];
int dato[4];
};

int Menu();
void Leer(struct stRegistro *reg);
void Mostrar(struct stRegistro *reg);
void Listar(long n, struct stRegistro *reg);
long LeeNumero();
void Empaquetar(FILE **fa);

int main()
{
struct stRegistro reg;
FILE *fa;
int opcion;
long numero;
fa = fopen("alea.dat", "r+b"); // Este modo permite leer y
escribir
if(!fa) fa = fopen("alea.dat", "w+b"); // si el fichero no existe, lo
crea.
do {
opcion = Menu();
switch(opcion) {
case '1': // Aadir registro
Leer(&reg);
// Insertar al final:
fseek(fa, 0, SEEK_END);
fwrite(&reg, sizeof(struct stRegistro), 1, fa);
break;
case '2': // Mostrar registro
clrscr();
printf("Mostrar registro: ");
numero = LeeNumero();
fseek(fa, numero*sizeof(struct stRegistro), SEEK_SET);
fread(&reg, sizeof(struct stRegistro), 1, fa);
Mostrar(&reg);
break;
case '3': // Eliminar registro
clrscr();
printf("Eliminar registro: ");
numero = LeeNumero();

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 1#

fread(&reg, sizeof(struct stRegistro), 1, fa);
reg.valido = 'N';
fwrite(&reg, sizeof(struct stRegistro), 1, fa);
break;
case '4': // Mostrar todo
rewind(fa);
numero = 0;
clrscr();
printf("Nombre Datos\n");
while(fread(&reg, sizeof(struct stRegistro), 1, fa))
Listar(numero++, &reg);
system("PAUSE");
break;
case '5': // Eliminar marcados
Empaquetar(&fa);
break;
}
} while(opcion != '0');
fclose(fa);
return 0;
}

// Muestra un men con las opciones disponibles y captura una opcin del
usuario
int Menu()
{
char resp[20];
do {
clrscr();
printf("MENU PRINCIPAL\n");
printf("--------------\n\n");
printf("1- Insertar registro\n");
printf("2- Mostrar registro\n");
printf("3- Eliminar registro\n");
printf("4- Mostrar todo\n");
printf("5- Eliminar registros marcados\n");
printf("0- Salir\n");
fgets(resp, 20, stdin);
} while(resp[0] < '0' && resp[0] > '5');
return resp[0];
}

// Permite que el usuario introduzca un registro por pantalla
void Leer(struct stRegistro *reg)
{
int i;
char numero[6];
clrscr();
printf("Leer registro:\n\n");
reg->valido = 'S';
printf("Nombre: ");
fgets(reg->nombre, 34, stdin);
// la funcin fgets captura el retorno de lnea, hay que eliminarlo:
for(i = strlen(reg->nombre)-1; i && reg->nombre[i] < ' '; i--)
reg->nombre[i] = 0;

Unidad Curricular: Algoritmia y Programacin Mdulo: Programacin I Pgina 1$

for(i = 0; i < 4; i++) {
printf("Dato[%1d]: ", i);
fgets(numero, 6, stdin);
reg->dato[i] = atoi(numero);
}
}

// Muestra un registro en pantalla, si no est marcado como borrado
void Mostrar(struct stRegistro *reg)
{
int i;
clrscr();
if(reg->valido == 'S') {
printf("Nombre: %s\n", reg->nombre);
for(i = 0; i < 4; i++) printf("Dato[%1d]: %d\n", i, reg->dato[i]);
}
getch();
}

// Muestra un registro por pantalla en forma de listado,
// si no est marcado como borrado
void Listar(long n, struct stRegistro *reg)
{
int i;
if(reg->valido == 'S') {
printf("[%6ld] %-34s", n, reg->nombre);
for(i = 0; i < 4; i++) printf(", %4d", reg->dato[i]);
printf("\n");
}
}

// Lee un nmero suministrado por el usuario
long LeeNumero()
{
char numero[6];
fgets(numero, 6, stdin);
return atoi(numero);
}

// Elimina los registros marcados como borrados
void Empaquetar(FILE **fa)
{
FILE *ftemp;
struct stRegistro reg;

ftemp = fopen("alea.tmp", "wb");
rewind(*fa);
while(fread(&reg, sizeof(struct stRegistro), 1, *fa))
if(reg.valido == 'S')
fwrite(&reg, sizeof(struct stRegistro), 1, ftemp);
fclose(ftemp);
fclose(*fa);
remove("alea.bak");
rename("alea.dat", "alea.bak");
rename("alea.tmp", "alea.dat");
*fa = fopen("alea.dat", "r+b");}

Guia Teorica Programacion II

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Guia Teorica Programacion II

Загружено:

Авторское право:

Доступные форматы

Docentes Colaboradores

Recopilado por: Docentes del rea de Programacin / Trayecto I / Trimestre II

Вам также может понравиться