Modulo -estructura_de_datos_i

UNIVERSIDAD TECNICA DE MANABÍ
FACULTAD DE CIENCIAS INFORMATICAS

ESTRUCTURA DE DATOS I

PROGRAMACIÓN EN C++

“Lo importante en un individuo, no es lo
que piensa, sino lo que hace”
J. Watson

FACULTAD DE CIENCIAS INFORMATICAS

FCI - 2008
Autores:
Ing. Esthela San Andres
Ing. Christian Torres

Universidad Tecnica de Manabí Facultad de Ciencias Informaticas

ESTRUCTURA DE DATOS I
PROGRAMACIÓN EN C++

Sistema de Información
Introducción.- Un sistema de información es un conjunto de elementos que interactúan entre sí
con el fin de apoyar las actividades de una empresa o negocio.

El equipo computacional: el hardware necesario para que el sistema de información pueda operar.

El recurso humano que interactúa con el Sistema de Información, el cual está formado por las personas
que utilizan el sistema.

Un sistema de información realiza cuatro actividades básicas: entrada, almacenamiento, procesamiento y
salida de información.

Entrada de Información: Es el proceso mediante el cual el Sistema de Información toma los datos que
requiere para procesar la información. Las entradas pueden ser manuales o automáticas. Las manuales
son aquellas que se proporcionan en forma directa por el usuario, mientras que las automáticas son datos
o información que provienen o son tomados de otros sistemas o módulos. Esto último se denomina
interfases automáticas.

Las unidades típicas de entrada de datos a las computadoras son las terminales, las cintas magnéticas,
las unidades de diskette, los códigos de barras, los escáners, la voz, los monitores sensibles al tacto, el
teclado y el mouse, entre otras.

Almacenamiento de información: El almacenamiento es una de las actividades o capacidades más
importantes que tiene una computadora, ya que a través de esta propiedad el sistema puede recordar la
información guardada en la sección o proceso anterior. Esta información suele ser almacenada en
estructuras de información denominadas archivos. La unidad típica de almacenamiento son los discos
magnéticos o discos duros, los discos flexibles o diskettes y los discos compactos (CD-ROM).

Procesamiento de Información: Es la capacidad del Sistema de Información para efectuar cálculos de
acuerdo con una secuencia de operaciones preestablecida. Estos cálculos pueden efectuarse con datos
introducidos recientemente en el sistema o bien con datos que están almacenados. Esta característica de
los sistemas permite la transformación de datos fuente en información que puede ser utilizada para la
toma de decisiones, lo que hace posible, entre otras cosas, que un tomador de decisiones genere una
ESTRUCTURADE DATOS I -- FCI

proyección financiera a partir de los datos que contiene un estado de resultados o un balance general de
un año base.

Salida de Información: La salida es la capacidad de un Sistema de Información para sacar la información
procesada o bien datos de entrada al exterior. Las unidades típicas de salida son las impresoras,
terminales, diskettes, cintas magnéticas, la voz, los graficadores y los plotters, entre otros. Es importante
aclarar que la salida de un Sistema de Información puede constituir la entrada a otro Sistema de
Información o módulo. En este caso, también existe una interfase automática de salida. Por ejemplo, el
Sistema de Control de Clientes tiene una interfase automática de salida con el Sistema de Contabilidad, ya
que genera las pólizas contables de los movimientos procesales de los clientes.

Elaborado por: Ing. Esthela San Andres e Ing. Christian Torres 1


A continuación se muestran las diferentes actividades que puede realizar un Sistema de Información de
Control de Clientes:

Actividades que realiza un Sistema de Información:
Entradas:

• Datos generales del cliente: nombre, dirección, tipo de cliente, etc.
• Políticas de créditos: límite de crédito, plazo de pago, etc.
• Facturas (interfase automático).
• Pagos, depuraciones, etc.
Proceso:

• Cálculo de antigüedad de saldos.
• Cálculo de intereses moratorios.
• Cálculo del saldo de un cliente.
Almacenamiento:

• Movimientos del mes (pagos, depuraciones).
• Catálogo de clientes.
• Facturas.

Salidas:

• Reporte de pagos.
• Estados de cuenta.
• Pólizas contables (interfase automática)
• Consultas de saldos en pantalla de una terminal.

Las diferentes actividades que realiza un Sistema de Información se pueden observar en el diseño
conceptual ilustrado en la en la figura 1.1.
ESTRUCTURA DE DATOS I -- FCI

Actividades que realiza un Sistema de Información, figura 1.1

2 Manual de Estructura de Datos


Tipos y Usos de los Sistemas de Información
Durante los próximos años, los Sistemas de Información cumplirán tres objetivos básicos dentro
de las organizaciones:

1. Automatización de procesos operativos.
2. Proporcionar información que sirva de apoyo al proceso de toma de decisiones.
3. Lograr ventajas competitivas a través de su implantación y uso.

Los Sistemas de Información que logran la automatización de procesos operativos dentro de una
organización, son llamados frecuentemente Sistemas Transaccionales, ya que su función primordial
consiste en procesar transacciones tales como pagos, cobros, pólizas, entradas, salidas, etc. Por otra
parte, los Sistemas de Información que apoyan el proceso de toma de decisiones son los Sistemas de
Soporte a la Toma de Decisiones, Sistemas para la Toma de Decisión de Grupo, Sistemas Expertos de
Soporte a la Toma de Decisiones y Sistema de Información para Ejecutivos. El tercer tipo de sistema, de
acuerdo con su uso u objetivos que cumplen, es el de los Sistemas Estratégicos, los cuales se desarrollan
en las organizaciones con el fin de lograr ventajas competitivas, a través del uso de la tecnología de
información.

Los tipos y usos de los Sistemas de Información se muestran en la figura 1.2.

A continuación se mencionan las principales características de estos tipos de Sistemas de Información.

Sistemas Transaccionales. Sus principales características son:

• A través de éstos suelen lograrse ahorros significativos de mano de obra, debido a que
automatizan tareas operativas de la organización.

• Con frecuencia son el primer tipo de Sistemas de Información que se implanta en las
organizaciones. Se empieza apoyando las tareas a nivel operativo de la organización.

• Son intensivos en entrada y salid de información; sus cálculos y procesos suelen ser simples y
poco sofisticados.

• Tienen la propiedad de ser recolectores de información, es decir, a través de estos sistemas se
cargan las grandes bases de información para su explotación posterior.

• Son fáciles de justificar ante la dirección general, ya que sus beneficios son visibles y palpables.



Sistemas de Apoyo de las Decisiones. Las principales características de estos son:

• Suelen introducirse después de haber implantado los Sistemas Transaccionales más relevantes de
la empresa, ya que estos últimos constituyen su plataforma de información.

• La información que generan sirve de apoyo a los mandos intermedios y a la alta administración en
el proceso de toma de decisiones.

• Suelen ser intensivos en cálculos y escasos en entradas y salidas de información. Así, por ejemplo,
un modelo de planeación financiera requiere poca información de entrada, genera poca
información como resultado, pero puede realizar muchos cálculos durante su proceso.

• No suelen ahorrar mano de obra. Debido a ello, la justificación económica para el desarrollo de
estos sistemas es difícil, ya que no se conocen los ingresos del proyecto de inversión.

• Suelen ser Sistemas de Información interactivos y amigables, con altos estándares de diseño
gráfico y visual, ya que están dirigidos al usuario final.

• Apoyan la toma de decisiones que, por su misma naturaleza son repetitivos y de decisiones no
estructuradas que no suelen repetirse. Por ejemplo, un Sistema de Compra de Materiales que
indique cuándo debe hacerse un pedido al proveedor o un Sistema de Simulación de Negocios
que apoye la decisión de introducir un nuevo producto al mercado.

• Estos sistemas pueden ser desarrollados directamente por el usuario final sin la participación
operativa de los analistas y programadores del área de informática.

• Este tipo de sistemas puede incluir la programación de la producción, compra de materiales, flujo
de fondos, proyecciones financieras, m od el os d e si mul aci ón de n eg oci os, mod el os d e
in v enta r ios, etc .

Sistemas Estratégicos. Sus principales características son:

• Su función primordial no es apoyar la automatización de procesos operativos ni proporcionar
información para apoyar la toma de decisiones.

• Suelen desarrollarse in house, es decir, dentro de la organización, por lo tanto no pueden
adaptarse fácilmente a paquetes disponibles en el mercado.

• Típicamente su forma de desarrollo es a base de incrementos y a través de su evolución dentro de
la organización. Se inicia con un proceso o función en particular y a partir de ahí se van agregando
nuevas funciones o procesos.

• Su función es lograr ventajas que los competidores no posean, tales como ventajas en costos y
servicios diferenciados con clientes y proveedores. En este contexto, los Sistema Estratégicos son
creadores de barreras de entrada al negocio. Por ejemplo, el uso de cajeros automáticos en los
bancos en un Sistema Estratégico, ya que brinda ventaja sobre un banco que no posee tal servicio.
Si un banco nuevo decide abrir sus puertas al público, tendrá que dar este servicio para tener un
nivel similar al de sus competidores.

• Apoyan el proceso de innovación de productos y proceso dentro de la empresa debido a que
buscan ventajas respecto a los competidores y una forma de hacerlo en innovando o creando
productos y procesos.



Tipos de datos
Bit. U nid ad de in fo rm ac ió n más s e nci ll a en el s istem a bi na r io.

B yte. Un idad d e i nf o r maci ón qu e c onst a d e 8 bits e qu i va le nt e a u n ú ni co
car áct er , c omo un a let r a, n úm er o o si gn o d e p untu aci ó n.

Ca ráct e r. Es u n el em ent o to mad o d e u n con ju nto d e s ímb ol os . E jem p lo :
a,b,c,0 ,1,%= …

Pa lab r a. C o nju nt o d e bi ts q ue p ue de n s e r ma ni pu lad o s p o r u na c om pu tado ra .

La l o ngit ud de u na p a lab ra e n un a c om put a do ra p ue de se r: 8, 16 , 31, etc.
De p end e d e l Mic r op r oc esad o r

Manipulación de bits

Digit al iz aci ó n de la in f or mac ió n. Se c o nv i ert e te xt o, so ni do o
imág e nes e n f o rmat o q ue p ue de s e r ent e ndid o p or l a PC.

Los m ic ro p ro ces ad or es ent ie nd en e l f o rmat o d e 0,1´s .

Los m ic ro p r oc esad o res det ect an cu and o un b it s e c ar ga y su
va lo r es igu al a 1

Se p u ed en r e pr es ent a r u na g ran di v e rsid ad de va l or es: ve rd a d y fa lso,
fem en in o y m ascu li n o, etc.

La e fic i enc ia d e las pc´ s no se basa e n l a c om pl ej id ad d e s u l óg ica

La e fic i enc ia d e las pc´ s se b asa en la v e loc id ad d e t rab aj o.

Ej em p lo de co mbi nac io nes p osib l es: 2 bits , 8 bits

Si s e uti li zan 8 bits pa ra re p r ese nta r u n ca rá cte r, se pu ed en re p r es ent ar h asta
256 ca ract e res d if e re n tes, p u esto qu e ex iste n 256 p at ro n es o co m bina ci on es
dif e re ntes d e 8 b its.

Los com p utad o res d if i e re n co n r es pe cto a l núm er o d e bits uti li zad os p a ra
r ep r es enta r un ca ráct e r

Clasificación de los tipos de datos

En fu nc ió n d e qu i en los def in e:

o Ti p os d e d atos está nd a r.

o Ti p os d e d atos de fi nid o s p or e l us ua r io

En fu nc ió n d e l a r ep r es ent aci ón int e rn a:

Ti p os d e d atos esc al ar es o sim p les

o

o Ti p os d e d atos est ruct u rad os.

Los ti p os d e d atos sim pl es s on l os si gui e ntes :

◦ Numé r ic os ( Int eg e r, R e al ) ·

◦ Lóg icos ( B oo le an ) ·

◦ Ca ráct e r (C ha r, St ri ng ) ·



Representación de datos simples

Dato. R e pr es ent aci ón f or ma d e hec hos , c onc e ptos o inst r ucci o nes

Ti p o de dat o. Un co nj u nto d e va l or es, a q ue ll o s qu e p ue de to ma r cua lq ui e r dat o
de d ich o t ip o.

Las va r iab les y co nsta ntes qu e fo rm an pa rte de un p r og ram a p e rte nec e n a u n
ti p o de d a t os d et er mi nad o. De esta f or ma, los va l or es as oci ad o s a dichas
va r iab les (o co nsta ntes ) p ue de n o pe r ar c on ot r os d e ac ue rd o a s u nat ur al ez a ( p .
e. d os nú me r os e nte r o s pu ed en s e r mu lti pl ic ados p er o n o ti e ne s e ntid o ha ce r
esa o pe r aci ón co n c ad e nas d e c a ract e res ).

NU M ER O S EN T ER O S

Si ut ili za mos 32 bits pa ra re p r ese nta r nú me ro ent e ros, dis p on em o s d e
2^32 c ombi nac io n es d i fe r ent es d e 0 y 1`s:

4294967 296 va l or es.

C omo te n em os qu e r ep r es enta r núm e ro n egat i vos y e l c e ro:

-2 147 483 6 48 a l +2 147 483 647

NU M ER O S R E A L ES .

(+|-) mantisa x 2 e x p o n e n t e

En l a not aci ó n d el pu nto fl ota nt e u n nú me r o r eal es tá r e p res e nta do p o r u na
hil e ra d e 32 bits f o rma da p o r un a ma ntisa d e 24 bits seg uid a de un ex p on ent e
de 8 bits.

La bas e se f ij a com o 10. Ta nt o la m ant isa como el e x po ne nt e son ent e ro s
bina r ios de co mp l em en to d obl e.

Tipos de datos abstractos

Un tipo de datos abstracto – TDA defi n e u na nu e va c las e de ob j eto o c onc e pt o
qu e p ue de ma ne ja rs e co n i nd e pe nd enc ia de la est ruct u ra de datos p a ra
r ep r es enta r lo .

Pa r a e ll o es nec es ar io es pec if ica r:

Las o p e rac io n es qu e s e pu ed e r ea li za r c on l os obj etos .

El e fe cto q ue se p r odu c e a l a ctua r c o n l as o p e rac io n es so br e los mis mos.

. U n TD A enc a psu la la d efi ni ci ón de l ti p o y t oda s l as o pe r aci on es c o n e ste ti p o.

Los l en gua j es de p ro gr amac ió n e ntr eg an al pr og ram ad or c ie rt os ti po s de dat o s
básic os o pr imit i vos, e sp ecif ic and o e l co nj unt o de va lo r es q u e un a v ar iab le d e
un o d e es os t i pos p u e de t om ar y el c on ju nto de o p e rac io n es r ea li z abl es s ob re
los m ism os.

P or e je mp l o, si s e dec l ar a e n C/ C++

unsigned int x, y;



La i nstr ucc ió n n = 9+10 de un p r og ram a d ond e = es el o pe ra do r d e asig nac ió n ,
el co nte ni do de la l oca l idad de al mac en ami e nt o da do p o r n ser á e l va l or 19.

Cad a tip o d e datos : es rec on oc ido p or l os e l e ment os de d atos qu e p ued e tom a r y po r
las o pe ra ci on es asoc ia das a é l. (su dom in io ) E jem p lo : en p asca l

Dom ini o ent e r o D= {0, 1, 2….ma x }

O pe r aci on es

Los T D As so n ge n er al i zac io nes de los ti p os de dat os bás ic os y d e las o p e rac io nes
p rim iti vas . U n TD A en caps ul a ti p os d e dat o s en el s e ntid o qu e e s pos ibl e p on e r l a
def in ici ón de l ti p o y todas las o pe ra ci on es con es e ti p o e n u n a secc ió n d e u n
p ro gr ama .

P or ej em pl o, s e p ue de def in ir un ti p o de d ato s abstra cto C O NJ UNT O [ Ah o198 8] c on e l
cua l se p u ed en d ef in i r l as sig ui ent es o pe r aci o nes:

AN UL A ( A )

Hac e v ací o a l c on ju nto A

UNI ON ( A, B, C )

Co nstr u y e el c o nju nt o C a p art i r d e la un ió n de los co nj unt os A y
B.

T A M AÑ O( A )

Ent r eg a l a ca nti dad de el em ent os d e l co nj unt o A.

El co mp o ne nt e bás ico de una est r uctu ra de d atos es la c el da.

La c eld a a lma ce na un v al or tom ad o d e a lgú n t i po d e dat o s im pl e o c o mpu est o

El m eca nism o de ag r e gaci ón d e c el das ll am ado a r re gl o es una c o lec ci ón de
el em ent os d e t ip o hom og én eo .

A r re gl o b idim e nsi on al en C/ C++

int w[5][3]

w[ i ] [j ] = b [ i * n + j]

n es la c ant ida d d e
col umn as d el a r re gl o

w[ 2] [0 ] = b [6 ]



Estructuras de datos
So n datos elementales aquellos que se consideran indivisibles en unidades más
simples.

Un a est ru ctu ra d e dat os es u na c las e de d atos qu e s e pu ed e ca ract e ri za r po r s u
or ga ni zac ió n y o pe r aci on es d ef in idas s ob r e e lla . Al gun as v eces a es tas est ru ctu ras s e
les ll ama ti pos d e dat o s.

Los ti pos d e d atos más fr ec u ent es uti li z ados en los d if er e nt es l eng ua jes de
p ro gr amac i ón s on :

Lógicas de datos.- En un p r og ram a, c ada v a r iabl e p e rt en ec e a al gu na es t ruct u ra d e
datos e xp líc ita o im p líc itam ent e d ef in ida, la c ual det e rmi na el c o nju nto d e op e rac i on e s
va lid as pa ra e ll a.

Primitivas y simples.- A qu e ll as q ue no está n com p uest as p o r ot r as est ruct u ras d e
datos p o r ej em pl o, ent e ros, bo ol ea n os y ca r ac ter es.

Lineales: pilas , c olas y listas li gad as l in ea l es.

No lineales incluyen grafos y á rb ol es.

Organización de archivos.- Las técnic as de estr uctu ra ci ón d e datos a pl ica das a
con ju ntos de dat os qu e los s iste mas o p e rati v os ma n eja n c o mo ca jas ne g ras
comú nm ent e s e lla ma n O rg a ni za c i ón de A rc h iv o s.

CLASIFICACIÓN DE LAS ESTRUCTURAS DE DATOS
Se clasifican en:
a) Por su almacenamiento
b) Por su organización
c) Por su comportamiento

a) Por su almacenamiento.- Se clasifican en:
Internas
Externas

Internas.- Son aquellas cuyas estructuras se almacena en la memoria principal.
Externas.- Son aquellas que se almacenan en las memorias secundarias de un sistema de computadoras.

b) Por su organización.- Se clasifican en:
Estáticas
Dinámicas

Estáticas.- son aquellas cuya agrupación de memoria no se disminuye o aumenta estas son: cadenas,
conjuntos, escalares, entre otros.
Dinámicas.- Son aquellas cuya agrupación de memoria pueden aumentar o disminuir durante la ejecución
del programa, estas son: pila, colas, listas.

d) Por su comportamiento.- Se clasifican en:
Simples
Compuesto o Estructurados

Simples.-Son aquellas que almacenan un valor y son:

Enteros
Escalares Real
Lógicos
Caracteres



Compuesto.- Son aquellos que almacenan múltiples valores en su estructura y son los siguientes:

Cadenas
Arreglos
Conjuntos
Registros
Listas
Pilas
Colas
Árboles
Archivos
Base de datos

Enteros
Reales
Clasificación de las estructuras de Datos

Simples Caracteres
Cadena
Booleano

Arreglo
Estático Conjunto
Registro

Listas
Estructurados Lineales Pilas
Colas
Dinámicos

No Lineales Árboles
Grafos

Los ti pos d e dat os sim pl es pu ed en s er o rga ni zad os e n di fe r ent es est ruct u ras d e dat os :
estát icas y di nám icas.

Las estructuras de datos estáticas:
So n a q ue ll as en las q ue el t ama ño oc u pad o en m em o ri a se d e fin e a ntes de q ue e l
p ro gr ama se ej ecut e y n o pu ed e m od if ica rs e dic ho tam añ o d u rant e la e j ecuc ió n de l
p ro gr ama .

Est as est r uctu ras est á n im p le me ntad as en c a si tod o s los l en gua j es.

Su pr inc i pa l c a ract e rís tica es qu e ocu p an so lo u na casi ll a de m em or ia, po r l o t ant o
una v a ria bl e sim p l e h ace r ef e re nc ia a u n ú n ico v al o r a la v ez , d en tro de est e g r up o



de d atos s e en cu ent ra : ent e ros , re al es, c a ract e res, bo lé an os, en um e r ados y s ub ra ng os
(l os últi mos n o e x iste n en al gu nos l eng ua jes d e p rog r amac ió n )

Las estructuras de datos dinámicas:
No ti en e n las lim itac io nes o r est ri cci on es en el ta ma ño d e m em or ia ocu p ada qu e s o n
p ro p ias d e las est ruct u ras estát icas .

M edi ant e el us o de u n ti p o d e dat os es pe cifi co, d en omi na do p u nte r o, es p osib l e
const r ui r est ru ctu ras d e dat os di nám icas qu e no s on so p o rtad as p o r la ma y o ría d e l os
le ngu aj es, p er o qu e en aq u el los q ue s i ti en en estas c ar act er ístic as o f r ece n so lu ci on es
efi cac es y ef ect iv as en la s ol uci ón d e pr ob lem as co mp l ej os.

Se c a ract e ri za po r el h ech o d e q ue c o n un n omb re s e ha ce r ef er e n cia a u n g ru p o de
casi llas d e m emo r ia. E s dec i r u n dat o est ruct ur ad o ti en e va r ios com po n ent es.

VARIABLES ESTRUCTURADAS O ARREGLOS
CONJUNTO DE DATOS DEL MISMO DEL MISMO TIPO AGRUPADOS BAJO UN
SOLO NOMBRE
Pa r a r ef e ri r nos a un o de el los s e ha ce r ef er enc ia a la p osic ió n qu e oc u pa el d at o
r esp ect o a los ot ros. Pu ed en s e r u ni dems io na les ( v ecto r es ) mu ltid ime nsi o nal es (
matr ic es )

Ej :

vo ca l= {a, e,i ,o, u }

La l ista d e c las e c o n n otas

VECTORES
A r re gl os u ni dim ens in al es:

Ej em p lo:

• Lista d e Cl ase

• Co la p ar a c om p ra r ti ck est

• Voca les d el abe ce da ri o .

OPERACIONES CON VECTORES
P ode mos hac e r c on un v ecto r:

• Lle na r

• Most r ar

• O rd en ar

• Busc a r:

• Se cu enc ia l

• Bi na ri a



Estructuras

Supongamos que queremos hacer una agenda con los números de teléfono de nuestros amigos.
Necesitaríamos un array de Cadenas para almacenar sus nombres, otro para sus apellidos y otro para sus
números de teléfono. Esto puede hacer que el programa quede desordenado y difícil de seguir. Y aquí es
donde vienen en nuestro auxilio las estructuras.

Para definir una estructura usamos el siguiente formato:

struct nombre_de_la_estructura {
campos de estructura;
};

NOTA: Es importante no olvidar el ';' del final, si no a veces se obtienen errores extraños.

Para nuestro ejemplo podemos crear una estructura en la que almacenaremos los datos de cada persona.
Vamos a crear una declaración de estructura llamada amigo:

struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
char edad;
};
A cada elemento de esta estructura (nombre, apellido, teléfono) se le llama campo o miembro. (NOTA: He
declarado edad como char porque no conozco a nadie con más de 127 años.

Ahora ya tenemos definida la estructura, pero aun no podemos usarla. Necesitamos declarar una variable
con esa estructura.

struct estructura_amigo amigo;

Ahora la variable amigo es de tipo estructura_amigo. Para acceder al nombre de amigo usamos:
amigo.nombre. Vamos a ver un ejemplo de aplicación de esta estructura. (NOTA: En el siguiente ejemplo
los datos no se guardan en disco así que cuanda acaba la ejecución del programa se pierden).

#include <stdio.h>
struct estructura_amigo {/* Definimos la estructura estructura_amigo */
char nombre[30];
char apellido[40];
char telefono[10];
char edad;
};

struct estructura_amigo amigo;
void main()
{

printf( "Escribe el nombre del amigo: " );
fflush( stdout );
scanf( "%s", &amigo.nombre );
printf( "Escribe el apellido del amigo: " );
fflush( stdout );
scanf( "%s", &amigo.apellido );
printf( "Escribe el número de teléfono del amigo: " );
fflush( stdout );
scanf( "%s", &amigo.telefono );
printf( "El amigo %s %s tiene el número: %s.n", amigo.nombre,
amigo.apellido, amigo.telefono );
}



Este ejemplo estaría mejor usando gets que scanf, ya que puede haber nombres compuestos que scanf no
cogería por los espacios.

Se podría haber declarado directamente la variable amigo:

char nombre[30];
char apellido[40];
char telefono[10];
} amigo;

Arrays de estructuras

Supongamos ahora que queremos guardar la información de varios amigos. Con una variable de estructura
sólo podemos guardar los datos de uno. Para manejar los datos de más gente (al conjunto de todos los
datos de cada persona se les llama REGISTRO) necesitamos declarar arrays de estructuras.

¿Cómo se hace esto? Siguiendo nuestro ejemplo vamos a crear un array de ELEMENTOS elementos:

struct estructura_amigo amigo[ELEMENTOS];

Ahora necesitamos saber cómo acceder a cada elemento del array. La variable definida es amigo, por lo
tanto para acceder al primer elemento usaremos amigo[0] y a su miembro nombre: amigo[0].nombre.
Veamoslo en un ejemplo en el que se supone que tenemos que meter los datos de tres amigos:

#include <stdio.h>
#define ELEMENTOS 3
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo[ELEMENTOS];

void main()
{
int num_amigo;
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf( "nDatos del amigo número %i:n", num_amigo+1 );
printf( "Nombre: " ); fflush( stdout );
gets(amigo[num_amigo].nombre);
printf( "Apellido: " ); fflush( stdout );

gets(amigo[num_amigo].apellido);
printf( "Teléfono: " ); fflush( stdout );
gets(amigo[num_amigo].telefono);
printf( "Edad: " ); fflush( stdout );
scanf( "%i", &amigo[num_amigo].edad );
while(getchar()!='n');
}
/* Ahora imprimimos sus datos */
{
printf( "El amigo %s ", amigo[num_amigo].nombre );
printf( "%s tiene ", amigo[num_amigo].apellido );



printf( "%i años ", amigo[num_amigo].edad );
printf( "y su teléfono es el %s.n" , amigo[num_amigo].telefono );
}
}
IMPORTANTE: Quizás alguien se pregunte qué pinta la línea esa de while(getchar()!='n');. Esta línea se usa
para vaciar el buffer de entrada. Para más información consulta Qué son los buffer y cómo funcionan.

Inicializar una estructura

A las estructuras se les pueden dar valores iniciales de manera análoga a como hacíamos con los arrays.
Primero tenemos que definir la estructura y luego cuando declaramos una variable como estructura le
damos el valor inicial que queramos. Recordemos que esto no es en absoluto necesario. Para la estructura
que hemos definido antes sería por ejemplo:

struct estructura_amigo amigo = {
"Juanjo",
"Lopez",
"592-0483",
30
};

NOTA: En algunos compiladores es posible que se exiga poner antes de struct la palabra static.

Por supuesto hemos de meter en cada campo el tipo de datos correcto. La definición de la estructura es:

char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
por lo tanto el nombre ("Juanjo") debe ser una cadena de no más de 29 letras (recordemos que hay que
reservar un espacio para el símbolo '0'), el apellido ("Lopez") una cadena de menos de 39, el teléfono una
de 9 y la edad debe ser de tipo char.

Vamos a ver la inicialización de estructuras en acción:

#include <stdio.h>
char nombre[30];
char apellido[40];
char telefono[10];
int edad;

};
"Juanjo",
"Lopez",
"592-0483",
30
};
int main()
{
printf( "%s tiene ", amigo.apellido );
printf( "%i años ", amigo.edad );
printf( "y su teléfono es el %s.n" , amigo.telefono );



}

También se puede inicializar un array de estructuras de la forma siguiente:

struct estructura_amigo amigo[] =
{
"Juanjo", "Lopez", "504-4342", 30,
"Marcos", "Gamindez", "405-4823", 42,
"Ana", "Martinez", "533-5694", 20
};

En este ejemplo cada línea es un registro. Como sucedía en los arrays si damos valores iniciales al array de
estructuras no hace falta indicar cuántos elementos va a tener. En este caso la matriz tiene 3 elementos,
que son los que le hemos pasado.

Paso de estructuras a funciones

Las estructuras se pueden pasar directamente a una función igual que hacíamos con las variables. Por
supuesto en la definición de la función debemos indicar el tipo de argumento que usamos:

int nombre_función ( struct nombre_de_la_estructura nombre_de_la variable_estructura )

En el ejemplo siguiente se usa una función llamada suma que calcula cual será la edad 20 años más tarde
(simplemente suma 20 a la edad). Esta función toma como argumento la variable estructura arg_amigo.
Cuando se ejecuta el programa llamamos a suma desde main y en esta variable se copia el contenido de la
variable amigo.

Esta función devuelve un valor entero (porque está declarada como int) y el valor que devuelve (mediante
return) es la suma.

#include <stdio.h>

char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};

"Juanjo",
"Lopez",
"592-0483",
30
};

int suma( struct estructura_amigo arg_amigo )
{
return arg_amigo.edad+20;
}
int main()



{
printf( "y dentro de 20 años tendrá %i.n", suma(amigo) );
}

Si dentro de la función suma hubiésemos cambiado algún valor de la estructura, dado que es una copia no
hubiera afectado a la variable amigo de main. Es decir, si dentro de 'suma' hacemos arg_amigo.edad = 20;
el valor de arg_amigo cambiará, pero el de amigo seguirá siendo 30.

También se pueden pasar estructuras mediante punteros o se puede pasar simplemente un miembro (o
campo) de la estructura.

Si usamos punteros para pasar estructuras como argumentos habrá que hacer unos cambios al código
anterior (en negrita y subrrayado):

int suma( struct estructura_amigo *arg_amigo )
{
return arg_amigo->edad+20;
}
int main()
{
printf( "y dentro de 20 años tendrá %i.n", suma(&amigo) );
}
Lo primero será indicar a la función suma que lo que va a recibir es un puntero, para eso ponemos el *
(asterisco). Segundo, como dentro de la función suma usamos un puntero a estructura y no una variable
estructura debemos cambiar el '.' (punto) por el '->'. Tercero, dentro de main cuando llamamos a suma
debemos pasar la dirección de amigo, no su valor, por lo tanto debemos poner '&' delante de amigo.

Si usamos punteros a estructuras corremos el riesgo (o tenemos la ventaja, según cómo se mire) de poder
cambiar los datos de la estructura de la variable amigo de main.

Pasar sólo miembros de la estructura

Otra posibilidad es no pasar toda la estructura a la función sino tan sólo los miembros que sean
necesarios. Los ejemplos anteriores serían más correctos usando esta tercera opción, ya que sólo usamos
el miembro 'edad':

int suma( char edad )
{
return edad+20;
}

int main()
{
printf( "y dentro de 20 años tendrá %i.n", suma(amigo.edad) );
}
Por supuesto a la función suma hay que indicarle que va a recibir una variable tipo char (amigo->edad es
de tipo char).



Estructuras dentro de estructuras (Anidadas)

Es posible crear estructuras que tengan como miembros otras estructuras. Esto tiene diversas utilidades,
por ejemplo tener la estructura de datos más ordenada. Imaginemos la siguiente situación: una tienda de
música quiere hacer un programa para el inventario de los discos, cintas y cd's que tienen. Para cada título
quiere conocer las existencias en cada soporte (cinta, disco, cd), y los datos del proveedor (el que le vende
ese disco). Podría pensar en una estructura así:

struct inventario {
char titulo[30];
char autor[40];
int existencias_discos;
int existencias_cintas;
int existencias_cd;
char nombre_proveedor[40];
char telefono_proveedor[10];
char direccion_proveedor[100];
};

Sin embargo utilizando estructuras anidadas se podría hacer de esta otra forma más ordenada:

struct estruc_existencias {
int discos;
int cintas;
int cd;
};
struct estruc_proveedor {
char nombre[40];
char telefono[10];
char direccion[100];
};

struct estruc_inventario {
char titulo[30];
char autor[40];
struct estruc_existencias existencias;
struct estruc_proveedor proveedor;
} inventario;

Ahora para acceder al número de cd de cierto título usaríamos lo siguiente:

inventario.existencias.cd

y para acceder al nombre del proveedor:

inventario.proveedor.nombre



Tipos de datos definidos por el usuario
Typedef

Ya conocemos los tipos de datos que nos ofrece C: char, int, float, double con sus variantes unsigned,
arrays y punteros. Además tenemos las estructuras. Pero existe una forma de dar nombre a los tipos ya
establecidos y a sus posibles variaciones: usando typedef. Con typedef podemos crear nombres para los
tipos de datos ya existentes, ya sea por capricho o para mejorar la legibilidad o la portabilidad del
programa.

Por ejemplo, hay muchos programas que definen muchas variables del tipo unsigned char. Imaginemos un
hipotético programa que dibuja una gráfica:

unsigned char x0, y0; /* Coordenadas del punto origen */

unsigned char x1, y1; /* Coordenadas del punto final */

unsigned char x, y; /* Coordenadas de un punto genérico */

int F; /* valor de la función en el punto (x,y) */

int i; /* Esta la usamos como contador para los bucles */

La definición del tipo unsigned char aparte de ser larga no nos da información de para qué se usa la
variable, sólo del tipo de dato que es.

Para definir nuestros propios tipos de datos debemos usar typedef de la siguiente forma:

typedef tipo_de_variable nombre_nuevo;

En nuestro ejemplo podríamos hacer:

typedef unsigned char COORD;

typedef int CONTADOR;

typedef int VALOR;

y ahora quedaría:

COORD x0, y0; /* punto origen */

COORD x1, y1; /* punto final */

COORD x, y; /* punto genérico */

VALOR F; /* valor de la función en el punto (x,y) */

CONTADOR i;



Ahora, nuestros nuevos tipos de datos, aparte de definir el tipo de variable nos dan información adicional
de las variables. Sabemos que x0, y0, x1, y1, x, y son coordenadas y que i es un contador sin necesidad de
indicarlo con un comentario.

Realmente no estamos creando nuevos tipos de datos, lo que estamos haciendo es darles un nombre más
cómodo para trabajar y con sentido para nosotros.

Punteros

También podemos definir tipos de punteros:

int *p, *q;

Podemos convertirlo en:

typedef int *ENTERO;

ENTERO p, q;

Aquí p, q son punteros aunque no lleven el operador '*', puesto que ya lo lleva ENTERO incorporado.

Arrays

También podemos declarar tipos array. Esto puede resultar más cómodo para la gente que viene de BASIC
o PASCAL, que estaban acostumbrados al tipo string en vez de char:

typedef char STRING[255];

STRING nombre;

donde nombre es realmente char nombre[255];.

Estructuras

También podemos definir tipos de estructuras. Antes, sin typedef:

struct _complejo {
double real;
double imaginario;
};

struct _complejo numero;
Con typedef:
typedef struct {
double real;
double imaginario;
} COMPLEJO;
COMPLEJO numero;



Asignación de Memoria Dinámica

Métodos de Asignación de Memoria

¿Cuáles son los métodos de asignación de memoria utilizados por el S.O.?

Cabe destacar que el almacenamiento y procesamiento de todos los datos es realizado en memoria RAM,
en un segmento destinado a ello (DS), por ello, es importante conocer los métodos de asignación de
memoria utilizados para su almacenamiento. Por un lado, se tiene la asignación estática de memoria en
donde se reserva la cantidad necesaria para almacenar los datos de cada estructura en tiempo de
compilación. Esto ocurre cuando el compilador convierte el código fuente (escrito en algún lenguaje de alto
nivel) a código objeto y solicita al S.O. la cantidad de memoria necesaria para manejar las estructuras que
el programador utilizó, quien según ciertos algoritmos de asignación de memoria, busca un bloque que
satisfaga los requerimientos de su cliente. Por otro lado se tiene la asignación dinámica en donde la
reserva de memoria se produce durante la ejecución del programa (tiempo de ejecución). Para ello, el
lenguaje Pascal cuenta con dos procedimientos: NEW() y DISPOSE() quienes realizan llamadas al S.O.
solicitándole un servicio en tiempos de ejecución. El procedimiento NEW ,por su parte, solicita reserva de
un espacio de memoria y DISPOSE la liberación de la memoria reservada a través de una variable especial
que direccionará el bloque asignado o liberado según sea el caso.

Ejemplo : Cuando se compilan las sgtes. Líneas de código se produce una asignación estática de memoria:

var linea: string [80];

(*Se solicita memoria para 80 caracteres --> 80 bytes)

operatoria: Array[1..100,1..100] of real;

(*Se solicita memoria para 100x100 reales -> 100 x 100 x 4 bytes)

interes : integer;

(*Se solicita memoria para 1 entero --> 2 bytes)

¿Cuántos bytes se reservarían para:?

datos: array [1..25] of double;

Para explicar con mayor detalle el concepto de memoria dinámica es necesario conocer el concepto ¡PUNTEROS!



Punteros

Son tipos de datos simples capaces de almacenar la posición de una variable en memoria principal. Se dice que ellos
direccionan a otras variables.

Ejemplo:

Se dice que las variables ubicadas en las posiciones 1003 y 1006 son
punteros, pues direccionan o "apuntan a" las posiciones 1000 y 1007
respectivamente.

Otra explicación.-
Un pu nte r o es u n obj et o q ue a p unta a otr o ob jet o. Es d eci r, u na va ri abl e cu yo va lo r es
la d i rec ci ón de mem o ri a d e ot ra va ri abl e.

No h a y qu e c o nfu ndi r una di r ecc ió n d e m em or ia co n el co nte ni do d e esa d i re cci ón d e
mem or ia .

i nt x = 2 5;

D i rec ci ón 15 02 1504 1 506 1508

La di r ecc ió n d e la va r ia ble x ( & x) es 1502

El co nt en ido d e l a va ri a ble x es 2 5

Las di rec ci on es de m e mo ria d e p end en d e l a ar q uit ectu r a de l o rd en ado r y de l a gest ió n
qu e e l sist ema o p e rati v o h aga de e ll a.

En l en gua j e e nsam bla d or se deb e ind ica r num é ric ame nt e l a pos ici ón físic a d e m em or i a
en qu e qu e re mos a lma cen a r un d ato. D e a hí qu e est e l en gu aj e de p end a tant o d e l a
má qui na e n l a qu e s e a pl i qu e.

En C n o d eb em os, n i p od emos , i nd ica r num é r icam ent e la di r ecc ió n de m em o ri a, s i n o
qu e ut il iz amos una eti qu et a q ue c on oc em os com o va r iab le ( en su día d efi ni mos l as
va r iab les com o di r ecci on es d e m em o ri a) . L o qu e n os i nte r esa es al mace na r un dat o, y
no la l oca li zac ió n ex act a d e es e d ato e n m em o ri a.



Un a v ar iab l e p unt e ro s e dec la r a com o tod as l as va r iab les. D eb e se r del m ismo t ip o qu e
la va r iab le a pu ntad a. S u id e ntif ica do r va p r ec edi do de un ast e risc o ( *):

i nt * p u nt;

Es un a v ar iab l e pu nt er o q ue a pu nta a va ri ab le qu e c o nti en e un d a to d e ti po ent e ro
lla mad a pu nt.

ch a r *c ar:

Es un p unt e ro a va ri abl e d e ti p o c ar áct er .

l o ng f lo at *n um;

f lo at * mat[ 5] ; // . . .

Es d eci r: ha y ta ntos tip os d e p unt e ros c omo t ip os d e dat os, aun q u e tambi é n
pu ed en de cla r ars e pu nt er os a estruct ur as más c om p le jas ( func i on es, st r uct ,
fich e ros ... ) e i ncl uso p u nte r os vac íos ( v oid ) y pu nt er os nu los (N ULL ).

Dec la rac ió n d e v ar iab le s pu nt er o: S ea un f rag ment o d e p r og ram a e n C:

cha r dat o; // v a riab l e q ue al mac en a rá un c a r ácte r.

cha r * p unt; //d ec la r aci ón de p unt e ro a c ar ácte r.

pu nt = & dat o; // e n l a va r iab le p unt gu ar dam o s la d i re cci ón
// d e m em o ria d e l a va r iab le dat o; pu nt a p u nta
// a d ato . Ambas so n del mism o t ip o, ch ar.

int * p unt = N ULL, va r = 14;

pu nt = & va r;

p ri ntf (“ %# X, %# X ”, pu nt, & va r ) // la m ism a s ali da: di r ecci ón

p ri ntf (“ n% d, %d ”, * pu nt, va r ); //sa lid a: 1 4, 14

H a y qu e t en e r c uid ad o c on las di r ecci on es a pu ntad as:

p ri ntf (“ %d, %d ”, * ( pu n t+1), v a r+1 );

*( pu nt + 1 ) r e pes e nta el v al o r co nt en ida e n la d i rec ci ón de m em o ri a a um enta da en
una p osi ci ón ( int=2 by tes) , qu e s e rá un v al or n o d ese ad o. Si n emb ar go v ar +1
r ep r es enta e l va lo r 15.

pu nt + 1 r e p r ese nta l o m ism o qu e &v a r + 1 ( a van ce en la d ir ecc i ón d e m em o ria d e
va r ).

Al tr aba ja r c on p unt e r o s se em pl ea n d os o pe r ado r es esp ec íf icos :

O pe r ado r d e d i r ecci ón : & R e p r ese nta la di r ecc ió n de m em o ri a de la va r iab le
qu e l e sig u e:

&fn um r e p res en ta la di r ecc ió n d e f num .

O p er ad o r d e c o nte nid o o i nd ir ecc i ón: *

El o p er ad o r * a pl ic ado al nomb r e d e u n pu nt er o i nd ica el va l or de la va r iab le
ap unt ada:

flo at alt ur a = 2 6.92, *ap unt a;



ap unt a = &a ltu r a; // in i cia li zac ió n d el p unt e ro

flo at alt ur a = 2 6.92, * ap unt a;

ap unt a = &a ltu r a; // in i cia li zac ió n d el p unt e ro

.p ri ntf ( “n %f ”, a ltu r a) ; //sa li da 2 6.92

.p ri ntf ( “n %f ”, * a punt a );

No s e d eb e co nf und i r e l o p e rad o r * en l a d ecl ar aci ón de l pu nt er o:

int * p;

Co n el o pe r ad or * en la s inst ru cci on es:

* p = 27;

p ri ntf ( “ n Co nte ni do = %d ”, *p );

Veam os c on u n e j em pl o en C la dif e r enc ia e ntr e to dos est os c onc e pt o s

Veam os el a rch i vo

- p unt0 .c pp

- p unt1 .c pp

Es d ec i r: int x = 25, *p int;

pi nt = & x;

La va ri abl e p int c onti e ne l a d ir ecc ió n de m em or ia d e la v ar iab l e x. L a ex p r esi ón: * pi nt
r ep r es enta el va lo r de la v a riab l e ( x) a p unt ad a, es dec i r 25. La v a ri abl e p int tamb ié n
tie ne su p ro p ia di r ecci ó n: & pi nt

Veam os c on ot r o ej em p lo e n C la di fe r enc ia e n tre tod os est os c onc e pt os

vo id mai n ( vo id ) {

int a, b, c , * p1, *p 2;

vo id *p ;

p1 = & a; // P aso 1. La di r ecci ó n d e a es asig nad a a p 1

*p1 = 1; // P as o 2. p1 (a ) es i gu al a 1. E qu i va le a a = 1;

p2 = & b; / / Pas o 3. La d i re cci ón de b es asig nad a a p2

*p2 = 2; // P aso 4. p 2 (b) es ig ua l a 2. E qu i va le a b = 2;

p1 = p 2; // Pas o 5. El va l or de l p1 = p2

*p1 = 0; // P aso 6. b = 0

p2 = & c; / / Pas o 7 . La d i rec ci ón de c es a sign ada a p2

*p2 = 3; // Pas o 8 . c = 3

p ri ntf (" %d % d %d n ", a, b, c ); / / Pas o 9. ¿Q u é se im p rim e ?

p = p1 ; / / Pas o 1 0. p co nti e ne la di r ecci ón de p1

p = p2 ; // Pas o 11. p1= p2;



*p1 = 1; / / Pas o 12. c = 1

p ri ntf (" %d % d %d n ", a, b, c ); // Pas o 13 . ¿ Qu é s e i mp r im e?

}

Vamos a h ac er un se g uim ie nto de las di r ecc i on es d e m em o ria y de los v al or es d e las
va r iab les e n cad a pas o. Su p on em os qu e l a va r iab le a es co lo cad a e n l a di r ecc ió n
0000, b e n l a sig ui e n te, es d eci r 0 002, co n u n o ffs et d e 2 b yt e s, p o r se r v al o res
int eg er .

Se t rat a d e un sist em a de pos ici o nes re lat i va s de mem o ri a. S e v e rá e n ar itm étic a d e
pu nt er os.

Se obti en e e l s igu i ent e cu ad ro. En él r ef l eja m os las di r ecci o nes re lat iv as d e me mo r ia y
los c amb ios e n ca da un o d e l os pas os m a rcad o s:

Inic ia li zac ió n d e pu nt er os( I) :

Si < Alm ac en ami ent o> es e xte r n o stat ic, <E x p res io n> deb e rá s e r u na e x p res ió n

const ant e d el ti p o < Ti p o> ex p r esad o.

Si < Al mac en ami e nto> es aut o, ent on ces < E x p res io n> p u ed e s er cu al qu i er e x p res i ón
del < Ti p o> esp ec if icad o.

Ej em p los:

1) La co nstant e ent e ra 0, NULL (c er o ) p r o po rc io n a un pu nte r o nu l o a cu al qu i er ti p o
de d ato:

int *p;



p = NUL L; // actu al iz aci ó n

2) El no mb re d e un a r ra y d e a lma ce nam i ent o stati c o ext e rn s e t r ansf o rma s eg ún la
ex p r esi ón:

a ) f l oat m at [12 ];

fl oat * p unt = mat;

b) fl o at mat [12 ];

f lo at * p unt = & mat [0 ];

3) U n “ cast ” pu nt er o a pu nt er o:

int *p unt = ( int *) 123. 456;

Inic ia li za e l pu nte r o c o n e l ent e ro .

4) U n punt e r o a ca ráct e r pu ed e i nic ia li za rs e e n l a f or ma:

cha r *c ad en a = Est o e s un a cad e na ”;

5) S e p u ede n suma r o r esta r v al o res e nt er os a las dir ecc io n es de m e mo ria en l a fo rma :
(a rit mét ica de p unt e r os)

st atic int x;

int * pu nt = & x+2, *p = & x-1;

6) E qu i va le nci a: D os ti pos de fi nid os c omo p u nte r os a o bj eto P y pu n ter o a obj et o Q so n
e qu iv al e ntes s ó lo s i P y Q s on de l m ism o ti p o. A pl ica do a m atr ic es:

nomb r e_ pu nte r o = nom br e_m atr i z;



PUNTEROS Y ARRAYS
Se a el a rr a y d e una di mens ió n:

i nt mat [ ] = { 2, 16 , - 4, 29, 234, 1 2, 0, 3 };

en e l qu e c ada e le me nt o, po r s e r t ip o int, oc u p a dos b ytes de me mo ri a.

Su p on em os qu e la di re cció n d e m em o ri a d el p rim e r el em ent o, es 1 50 0:

& mat [0 ] es 1 500

& mat [1 ] s er á 1502

& mat [7 ] s er á 1514

int mat [ ] = {2 , 16, -4 , 29, 2 34, 12 , 0, 3} ;

En tot al los 8 el em ent o s ocu p an 16 b yt es.

P ode mos r e p res ent a r l as di r ecci o nes de mem or ia q u e oc u pa n l os el e ment os d e l a r ra y ,
los dat os qu e c ont ie n e y las p osic io n es d el a rr ay e n l a f o rma:

Di rec ci ón 1 500 1 502 1 504 1506 1 508 1510 151 2 1514

El em e nto
mat [0 ] mat [1 ] mat [2 ] mat [3 ] mat [4 ] mat [5 ] mat [6 ] m at[ 7]

El acc es o po dem os hac e rl o m edi ant e el ín dic e:

x = mat [3 ]+m a t[5 ]; // x = 2 9 + 1 2

pa ra sum ar l os el em ent os d e l a c ua rta y s e xta pos ic io nes .

C om o h em os d ich o q ue p od em os acc ede r p or pos ici ón y p or di r ec ció n: ¿ Es lo mism o
&mat [0 ] y mat?

Y &mat [1 ] = mat ++ ?

Veam os el có dig o d e un ej em p lo:

#inc lu de <stdi o.h >

#inc lu de <co ni o.h >

int m at[ 5] ={ 2, 16 , -4, 2 9, 234, 12, 0 , 3 }, i; // d ecl a rad as c omo gl oba l e s

vo id mai n () {

p ri ntf (" n% d", &mat [0 ] ); // res ult ad o: 15 00 ( di r ecci ón d e m em )

p ri ntf (" n% p ", m at ); / /r es ulta do: 1 500 ( " " " " " )

i ++; //i =1

p ri ntf (" n% p ", m at+ i); // r esu ltad o: 1 502 ( " " " " " )

p ri ntf (" n% d", * (ma t+i) ); // r esu ltad o: 16 ( va lo r de mat [1 ] o val o r

g etch ( ); }

Ej em p lo



Pa r ec e d edu ci rs e qu e a cced em os a l os e l em en tos d el a rr a y d e d os f o r mas:

- m ed iant e e l sub índ ice.

- m ed iant e s u d ir ecc ió n d e m em or ia.

El em e nto mat[ 0] mat [1 ] mat [2 ] m at[ 3] mat [4 ] mat [ 5] mat [6 ] m at[ 7]

Analizando las direcciones de memoria del array:

De lo ant e ri o r s e obt i en en v ar ias co ncl usi on es:

- Es lo mism o &m at[ 0] q ue mat, & mat [2 ] q ue mat + 2

- Pa r a pasa r de un e l em ent o a l si gu ie nte , es lo mism o:

Qu e el có dig o:

A esta fo rm a d e d es pl a za rs e e n m em o ria se l e ll ama



Aritmética de punteros

- A un a va ri abl e pu nt er o se l e p ue de asi gna r la dir ec ci ón d e cua l qu i er obj eto .

- A un a v ar iab l e pu nt er o se le pu ed e asi gna r l a dir ec ci ón d e otr a v ar ia ble pu nte r o
(si em p re qu e l as d os s eñ al en e l m ismo ob jet o )

- A un p unt e ro s e le p u e de in ici al iz ar co n el v al or N ULL

- Un a v a riab l e p unt e ro pu ed e se r rest ada o com pa ra da c on ot ra si amba s
ap unt an a el em ent os d e u n m ismo a r ra y.

- Se p ue de s uma r o rest ar va l or es ent e ros : p + +, p v+3 , te ni en do e n c ue nta qu e el
des pl az ami e nto ( offs et ) de p end e d e l ti p o d e d a to a pu nta do:

p++; // p a pu nta a l a sigu ie nt e di r ecc ió n

p v+=3 // p v a p unta 3* nº b ytes de l d ato a pu nt ado ( of fset)

Si t e nem os:

flo at *d ec ima l; / /su po nem os q ue a pu nta a 0 000

dec ima l++; //a p un ta a 0 004

- Obs e rv a r l as si gui e ntes inst ru cci on es:

i nt * p;

d oub l e * q;

v oid *r ; // p un ter o ge né r ic o

p = & 34; / / l a s const ant es no t i en en dir ec ci ón

p = & ( i+1 ); / / las ex p r esi on es no ti en en di r ecci ón

&i = p; // l as d ir ecc io n es n o s e pu ed e n camb ia r

p = q; // il e gal

p = ( int *) q; // l ega l



Uti li za nd o la aritmética de punteros nos despl az am os de u nas p osic io n es de
mem or ia a ot r as. Pe r o. ¿c óm o ac ce de r a l os co nt en idos de es a s pos ic io nes
util iz an do n otac ió n d e pu nt er os?

Em p le amos el o pe ra do r *, indirección que n os da e l co nt en ido d e la di r ecci ón d e
mem or ia a pu ntad a.

Y... ¿c óm o s e a pl ica la a rit mét ica d e pu nte r os pa r a d es pl az ar nos e n un a r ra y
bidim e nsi on al ?:

f lo a t mat[ 2] [4 ]; //d ecl a rac ió n d e l a r ra y

Uti li za nd o pu nte r os, la dec la rac ió n s e rá:

fl o at ( *mat ) [4 ]; / /a r ra y b idim e nsi on al

En d ond e mat es u n p unt e ro a u n g r up o co ntig u o d e a r r a ys mon od ime nsi o nal es
( ve cto r es) d e 4 el em en tos ca da un o.

E xist e, p or tant o un a e qu i va le nci a:

Rec o rd emos que *mat
r ep r es enta un puntero a la
primera fila. A la se gund a
fil a n os r ef e ri mos m e dia nte
*(m at+1 )+j p a ra las
dir ec ci on es y con

*(* (m at+1 )+j ) p ar a los
cont en id os. El
segu nd o subíndi ce actua
sob re la co lu mna .

Si en x[ 10 ][ 20 ] q u ie r o acc ed e r al e le me nto d e l a fi la 3 y la c ol umn a 6, l o h ag o
esc rib ie nd o x [2 ][ 5]. C o n n otac ió n d e p unt e ros , es e qu i va le nte a

* ( * ( x + 2 ) +5 )



ya qu e x + 2 es un pu nt er o a l a fi la 3. P or t ant o. E l co nt en ido de dich o pu nte r o,
*( x+2 ), es la fi la 3. Si m e d esp la z o 5 p os ici on es e n es a fi la l l e go a l a p osi ci ón
*( x+2 )+5, cu y o c ont en i do es * (* ( x+2 )+5 ). V e r dibu jo:

Si en x[ 10 ][ 20 ] q u ie r o acc ed e r al e le me nto d e l a fi la 3 y la c ol umn a 6, l o h ag o
esc rib ie nd o x [2 ] [5 ]. C on n otac ió n de punt e r os, lo qu e hac em os es co nsid e ra r qu e es
un a r ra y fo rm ad o p o r 10 ar ra ys u ni dim ens i o nal es (v ect o res ) d e 2 0 el em ent os cad a
un o, d e m od o qu e acc e do a x [2 ] [5 ] m ed iant e l a e x p res ió n:

* ( * ( x + 2 ) + 5)

ya qu e x + 2 es un pu nt er o a l a fi la 3. P or t ant o. E l co nt en ido de dich o pu nte r o,
*( x+2 ), es la fi la 3. Si m e d esp la z o 5 p os ici on es e n es a fi la l l e go a l a p osi ci ón
*( x+2 )+5, cu y o c ont en i do es * (* (x +2 )+5 ). L as sigu ie nt es e x p res io n es con p unt e ros s o n
vá lid as:

**x x [0 ] [0 ] ; *( *( x+1 ) ) x [1 ] [0 ]

*(* x+1 ) x [0 ] [1 ]; ** (x +1 ) x [1] [0 ]

Si e n

int a rr a y[ fi las ] [c ol umn as] ;

Qu i er o acc ed e r a l el e ment o a r ra y [ y ][ z ] p a ra asign a rl e un va l or , lo qu e e l com p il ad or
hac e es :

*(*array +columnas x y + z)) = 129; / /asig nac ió n

Si f ue r a int a r ra y [2 ] [5 ] y q uisi e ra as ig na r 12 9 al e le me nto d e l a fi l a 1 y co lu mna 2 ,
po nd rí a:

* (a r ra y + 5x1 + 1 )) = 129 ;

es d eci r, des de e l or ig e n d el ar r a y a va n za 6 po sici on es d e m em o ri a:



PUNTEROS A ARRAYS MATRICES
Un a r ra y m ult idim e nsi on al es, en r e ali dad, una co l ecci ón d e vect or es. S eg ún est o,
po de mos d ef in ir un ar ra y b idi me nsi on al c o mo u n p unt e r o a u n g ru p o co nti gu o d e
ar ra ys un id ime nsi o nal e s. Las d ec la rac io n es si gui ent es s on e q ui va l en tes:

int dat [fi l ] [co l ] i nt (*d at) [c ol ]

En g en e ra l:

tip o_d ato no mb re [d im1 ] [dim 2] . . . . . [di mp ]; e q ui va le a:

tip o_d ato (* no mb re ) [di m2] [d im3 ]. . . . . [d im p ];

El a r ra y: i nt va l or [ x ][ y ] [z ];

Pu ed e s e r re p r ese nta d o en la fo rm a:

i nt (* va lo r ) [y ] [ z] ;

O c om o u n AR R A Y D E P UN T ER O S:

int * v al or [ x ][ y ];

s in p a r ént esis

En su nu e va dec la r aci ó n d esa pa r ec e l a ú ltim a de s us di me nsi on es.

Veam os m ás d ecl a rac io nes de a rr a ys d e p unt e ros :

int x [10 ] [20 ]; int * x[ 10 ];

flo at p [10 ] [20 ] [30 ]; int * p[ 10 ][ 20 ];



Punteros a CADENAS DE CARACTERES

Un a c ad ena d e c ar act e r es es u n ar r ay d e c ar a cte res . La f or ma de d e fin i r u n pu nt er o a
una cad e na d e c a ract e r es:

c ha r *ca de na;

El id ent if icad o r d el ar ra y es l a di r ecc ió n d e comi e nz o d el a rr a y. Pa r a sab e r dó nd e
ter mi na la c ad en a, el c om pi lad o r a ñad e el ca r ácte r ‘ 0’ ( A SCI I 0, N UL L):

cha r * nomb r e = “ P E P E P ER E Z ”;

ARRAYS DE PUNTEROS A CADENAS DE CARACTERES
En un a r ra y d e pu nte r o s a cade nas d e ca r acte r es cad a el em e nto a p u nta a u n ca ráct e r.
La d ecl a rac ió n s er á:

cha r *c ad [10 ]; // po r e jem p lo

Grá fic am ent e p od ría se r:

- si l as di me nsi on es no son c o noc idas , sab r em os d ónd e c om ie n zan l a s cad en as,
p er o no d ó nde t e rm ina n. Pa ra el l o se ef ect úa la l la mad a reserva dinámica de
memoria (funci o nes ma ll oc, c al loc ( ), r ea ll oc ( ) y fr e e () de stdl ib.h ó al l oc.h ):

cha r c ad[ 10 ][ 80 ];

E qu i va le a ch ar **ca d r es er v and o 8 00 b yt es



La d ecl a rac ió n:

c ha r ca d[10 ] [80 ];

Res e rv a me mo ri a p ar a 10 cade nas de c ar ac ter es d e80 ca ra cte r es cada un a.
P er o en l a d ecl ar ac ió n com o a r ra y d e p unt e ros :

c ha r * cad [10 ];

El co mp il ad or d esco n oc e el t ama ño de l as cad en as: ¿ cuá nta me mo ri a r ese r va ?

- si e l a r ra y es stat ic y s e i nic ia li za n l as c ade nas e n e l p ro pi o códi go , e l
com pi lad o r c alc ul a l a d ime nsi ón n o ex p lic itad a (a r ra ys s in dim e nsi ón ex p líc ita ).

OTRAS CLASES DE PUNTEROS:
P unt e ros ge n ér ic os: S on t i po v oi d:

v oid *g en e ric o;

Los p unt e r os ti po v oid pu ed en a pu nta r a ot r o tip o d e dat os. Es un a op e rac ió n
del ica da q u e d e pe nd e d el ti p o d e c om pi la do r. Es c o nv e ni ent e em pl ea r e l
“cast in g” pa ra l a c on v e rsi ón. Aú n as í, n o tod a s las c on v e rsi on es están
p er miti das.

P unt e ro nu lo: En C u n pu nte r o qu e a pu nte a un o bj et o vá li do n un ca tend rá un
va lo r ce r o. E l va lo r c e r o s e ut il iz a pa ra i ndic a r qu e ha oc ur r id o a lgú n e r r or (e s
dec ir , qu e a lg un a o p e ra ció n n o s e h a po did o r e ali za r )

int * p = N UL L; // int * p =0;

Pu nte r os c onst ant es : U na d ec la ra ci ón de p u nte r o pr ec ed ida de co n st hac e
qu e e l ob j eto a pu ntad o sea un a c onst ant e (a u nq u e n o el p unt e ro ):

co nst ch a r * p = “V al lad ol id ”;

p [0 ] = ‘f’ // e r ro r. La c ad ena a pu nta da po r + es cte .

p = “ Puc el a ” //Ok . p a p unta a ot ra cade na .

Si l o qu e qu e r emos es dec la ra r un p unt e ro co nstant e;

cha r *co nst p = “ M edi na ”;

p [0 ] = ‘s’; // e rr o r: el ob jet o “ Me di n a”, es cte.

p = “ P eñ af ie l ”; //e r ro r: e l pu nte r o p e s const ant e.

Punt e r os a p unt e ros:

Ve r ej em p4.c p p, ej e mp11 .c pp y ej em p12.c p p

int ** pu nte r o; // pu nt er o a punt e r o a un obj eto i nt.

El ti p o de ob jet o a pu ntad o des pu és d e un a dobl e in d i re cci ón pu e de se r de
cua lq ui e r c las e.



P er mit e ma ne ja r a r ra ys d e mú lti p les d im e nsi on es c on n otac io ne s d el t i p o
***mat, d e múlt i pl e ind i re cci ón q ue pu ed en g en e ra r p r obl e mas si el
trat ami ent o no es el adec ua do. O j o a los “ p unt er os lo cos ”.

Punt e r os a dat os c o mp le jos: S e pu ed en d ecl a ra pu nte r os a d at os de fi nid os
po r e l us ua ri o (t y pe de f( ) ), a dat os st ruct, a fun ci on es, c om o a rg u ment os d e
func i on es...

Dec la rac io n es c om pl ej as:

U na d ec la rac ió n c om pl ej a es un id ent ifi cad o r con más d e d e u n op e r ado r. P ar a
int er p r eta r estas d ecl a rac io nes hac e f a lta sab e r qu e los c o r chet es y
pa r ént esis (o p e rad o r es a la de r ech a de l ide n tific ad or ti en e n p ri or i dad sob re
los aste ris cos (o p e ra do res a l a iz q ui e rda d el id e ntif ica do r. L os p ar ént es is y
co rch etes ti en e n l a m i sma p ri or id ad y s e e va lúa n d e i z qui e rd a a d e r echa . A la
iz q ui er da de l t od o el t ip o d e dat o. Em pl e and o p ar é ntes is s e pu ed e cambi ar el
or de n d e p ri o ri dad es. Las e x pr esi o nes ent r e pa r ént esis s e e v al úan p rim e ro , de
más i nte r nas a más e xt e rnas .

Pa r a i nte r p r eta r d ecl a r aci on es c om pl ej as p od em os se gu ir e l or de n:

1) Em p ez ar c on e l i dent if icad o r y ve r si haci a la d er ec ha ha y co rch etes o
pa r ént esis .

2) I nte r p r eta r es os c or ch etes o p ar é ntes is y v e r si ha cia la i z q ui er da h ay
aste risc os.

3 ) D ent ro de cad a ni v el d e pa r ént esis , d e más int e rn os a má s ext e rn os,
ap lic a r pu ntos 1 y 2.

Veam os un ej em p lo:

cha r *(* (* va r ) ( ) )[ 10 ]

La i nte r p r etac ió n es:

1. La v ar iab l e va r es d e cla rad a c om o

2. u n punt e r o a

3. u na f un ci ón q ue d ev ue l ve

4. u n punt e r o a

5. u n a r ra y d e 1 0 el em ent os, los cua l es so n

6. p unt e ros a

7. ob jet os d e t i po cha r.



Punteros a estructuras

Cómo no, también se pueden usar punteros con estructuras. Vamos a ver como funciona esto de los
punteros con estructuras. Primero de todo hay que definir la estructura de igual forma que hacíamos antes.
La diferencia está en que al declara la variable de tipo estructura debemos ponerle el operador '*' para
indicarle que es un puntero.

Creo que es importante recordar que un puntero no debe apuntar a un lugar cualquiera, debemos darle
una dirección válida donde apuntar. No podemos por ejemplo crear un puntero a estructura y meter los
datos directamente mediante ese puntero, no sabemos dónde apunta el puntero y los datos se
almacenarían en un lugar cualquiera.

Y para comprender cómo funcionan, nada mejor que un ejemplo. Este programa utiliza un puntero para
acceder a la información de la estructura:

#include <stdio.h>
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
"Juanjo",
"Lopez",
"592-0483",
30
};
struct estructura_amigo *p_amigo;
int main()
{
p_amigo = &amigo;
printf( "%s tiene ", p_amigo->apellido );
printf( "%i años ", p_amigo->edad );
printf( "y su teléfono es el %s.n" , p_amigo->telefono );
}

Has la definición del puntero p_amigo vemos que todo era igual que antes. p_amigo es un puntero a la
estructura estructura_amigo. Dado que es un puntero tenemos que indicarle dónde debe apuntar, en este
caso vamos a hacer que apunte a la variable amigo:

p_amigo = &amigo;

No debemos olvidar el operador & que significa 'dame la dirección donde está almacenado...'.

Ahora queremos acceder a cada campo de la estructura. Antes lo hacíamos usando el operador '.', pero,
como muestra el ejemplo, si se trabaja con punteros se debe usar el operador '->'. Este operador viene a
significar algo así como: "dame acceso al miembro ... del puntero ...".

Ya sólo nos queda saber cómo podemos utilizar los punteros para introducir datos en las estructuras. Lo
vamos a ver un ejemplo:

#include <stdio.h>
char nombre[30];



char apellido[40];
int edad;
};
struct estructura_amigo amigo, *p_amigo;
void main()
{
p_amigo = &amigo;
/* Introducimos los datos mediante punteros */
printf("Nombre: ");fflush(stdout);
gets(p_amigo->nombre);
printf("Apellido: ");fflush(stdout);
gets(p_amigo->apellido);
printf("Edad: ");fflush(stdout);
scanf( "%i", &p_amigo->edad );
/* Mostramos los datos */
printf( "El amigo %s ", p_amigo->nombre );
printf( "%i años.n", p_amigo->edad );
}
NOTA: p_amigo es un puntero que apunta a la estructura amigo. Sin embargo p_amigo->edad es una
variable de tipo int. Por eso al usar el scanf tenemos que poner el &.




Punteros a Arrays de estructuras

Por supuesto también podemos usar punteros con arrays de estructuras. La forma de trabajar es la misma,
lo único que tenemos que hacer es asegurarnos que el puntero inicialmente apunte al primer elemento,
luego saltar al siguiente hasta llegar al último.

#include <stdio.h>
#define ELEMENTOS 3
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};

struct estructura_amigo amigo[] =
{
"Juanjo", "Lopez", "504-4342", 30,
"Marcos", "Gamindez", "405-4823", 42,
"Ana", "Martinez", "533-5694", 20
};

struct estructura_amigo *p_amigo;
void main()
{
int num_amigo;
p_amigo = amigo; /* apuntamos al primer elemento del array */

{
printf( "%i años ", p_amigo->edad );
printf( "y su teléfono es el %s.n" , p_amigo->telefono );
/* y ahora saltamos al siguiente elemento */
p_amigo++;
}
}

En vez de p_amigo = amigo; se podía usar la forma p_amigo = &amigo[0];, es decir que apunte al primer
elemento (el elemento 0) del array. La primera forma creo que es más usada pero la segunda quizás indica
más claramente al lector principiante lo que se pretende.

Ahora veamos el ejemplo anterior de cómo introducir datos en un array de estructuras mediante punteros:

#include <stdio.h>
#define ELEMENTOS 3
char nombre[30];
char apellido[40];
int edad;
};

struct estructura_amigo amigo[ELEMENTOS], *p_amigo;

void main()



{
int num_amigo;
/* apuntamos al primer elemento */
p_amigo = amigo;

/* Introducimos los datos mediante punteros */
for ( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf("Datos amigo %in",num_amigo);
printf("Nombre: ");fflush(stdout);
gets(p_amigo->nombre);
printf("Apellido: ");fflush(stdout);
gets(p_amigo->apellido);
printf("Edad: ");fflush(stdout);
scanf( "%i", &p_amigo->edad );
/* vaciamos el buffer de entrada */
while(getchar()!='n');
/* saltamos al siguiente elemento */
p_amigo++;
}
p_amigo = amigo;
{
printf( "%i años.n", p_amigo->edad );
p_amigo++;
}
}

Es importante no olvidar que al terminar el primer bucle for el puntero p_amigo apunta al último elemento
del array de estructuras. Para mostrar los datos tenemos que hacer que vuelva a apuntar al primer
elemento y por eso usamos de nuevo p_amigo=amigo; (en negrita).



Modulo -estructura_de_datos_i

Modulo -estructura_de_datos_i

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Similar a Modulo -estructura_de_datos_i

Similar a Modulo -estructura_de_datos_i (20)

Modulo -estructura_de_datos_i