INFORMATICA
La tecnología
de la información y las comunicaciones
ha logrado tan alto grado de desarrollo que
hoy está en todas partes y, si no en todas, en la
mayoría de las actividades del ser humano: en la educación, la
industria, el
comercio, las
finanzas, la
investigación, etc.
Hoy en día, conocer la
tecnología y utilizarla ya no constituye ningún privilegio, por el
contrario, es una necesidad. El uso de la tecnología es un factor
determinante en los niveles de eficiencia y
competitividad
tanto a nivel empresarial como personal.
- BREVE HISTORIA DEL DESARROLLO DEL COMPUTADOR
Se dice que el antecesor del computador fue el ábaco, del cual se cree que pudo haber
tenido su origen hace cinco mil años y por su funcionalidad fue
utilizado hasta mediados del siglo pasado en Oriente Medio y Asia como instrumento de cálculo.
En nuestro medio, el ábaco,
aún se utiliza en las salas de billar.
Después del ábaco se hicieron
múltiples intentos hasta lograr el computador como hoy lo
conocemos.
John Napier (1550-1617) un matemático
inventó un dispositivo consistente en unos palillos con
números impresos que mediante un ingenioso y complicado
mecanismo le permitía realizar operaciones de
multiplicación y división.
Blaise Pascal (1.623-1.662), filósofo
francés, en 1642 presentó una máquina que
sumaba y restaba, ésta funcionaba con 8 ruedas giratorias,
dos para los decimales y seis para los enteros y que podía
manejar números entre 000.000 01 y 999.999 99.
Leibnitz (1646-1716) en 1672 presentó una
máquina que podía, además de sumar y restar,
multiplicar, dividir y calcular la raíz
cuadrada.
Joseph Jacquard (1.752-1.834) utilizó un
mecanismo de tarjetas
perforadas para controlar el dibujo formado
por los hilos de las telas confeccionadas por una máquina
de tejer.
Charles Babbage, matemático e inventor
inglés,
en 1822 diseñó su máquina diferencial para
el cálculo
de polinomios, que fue utilizada con éxito para el cálculo de tablas de navegación y artillería. Posteriormente trabajó en el diseño de una maquina de propósito general, que funcionaba con base en mecanismos de entrada y salida, memoria, unidad
de control y unidad
aritmético-lógica,
como los computadores modernos. La máquina no se pudo
construir mientras Babbage vivió.
Herman Hollerith, inventó un sistema de
computo automático para manipular los datos del censo
de Estados Unidos
en 1880, su máquina funcionaba con tarjetas
perforadas en las que mediante agujeros se representaba el
sexo, la edad, la raza etc. Ante las posibilidades comerciales de su máquina Hollerith dejó las oficinas del censo en 1896 para fundar su propia Compañía la Tabulating Machine Company. En 1900 había desarrollado una máquina que podía clasificar
300 tarjetas por minuto, una perforadora de tarjetas y una máquina de
cómputo semiautomática. En 1924, fusionó su compañía con otras dos
para formar la Internacional Bussines Machines hoy mundialmente conocida como IBM .
En los años siguientes, se trabajó
intensamente tratando de crear una máquina que permitiera
la realización de cálculos automáticos y a
gran velocidad.
Para no prolongar este texto más allá de lo necesario, se omiten algunos datos .
El 9 de Abril de 1943, John Mauchly y Lieutenant
Herman Goidstine recibieron aprobación para adelantar
un proyecto de
construcción de la primera computadora,
llamada ENIAC (Electronic Numerical integrator and Computer),
aunque el presupuesto
inicial fue de 150.000 dólares cuando la máquina
estuvo terminada el costo total
había sido de 486.804 dólares. En un test de prueba en
febrero de 1946 ENIAC resolvió en 2 horas un problema de
física
nuclear que previamente habría requerido 100 años
de trabajo de un hombre. Lo que
caracterizaba al ENIAC como a los ordenadores modernos no era
simplemente su velocidad de
cálculo sino el hecho de que combinando operaciones
permitía realizar tareas que antes eran
imposibles.
Entre 1939 y 1944 Howard Aiken de la universidad de
Harvard en colaboración con IBM desarrolló el Mark
1 también conocido como calculador Automático de
Secuencia Controlada. Este podía multiplicar tres
números de 8 dígitos en 1 segundo y operaba con
números de hasta 23 dígitos.
En 1946 el matemático húngaro John Von
Neumann propuso una versión modificada del Eniac a la
que le llamó Edvac (Electronic Discrete Variable Automatic
Computer) que se construyó en 1952. A diferencia con el
ENIAC, esta maquina empleaba aritmética binaria, lo que
simplificaba los circuitos
electrónicos de cálculo, y trabajaba con programas
almacenados
En 1953 IBM fabricó su primer computador para aplicaciones científicas el 701 y seguidamente 702 y el 705, este último fue un sistema revolucionario, el primero en emplear memorias de
núcleos de ferrita. Con esta producción y mediante una adecuada estrategia comercial IBM tomo la delantera en las ventas de tecnología en todo el mundo .
A partir de esta época se siguieron fabricando y
comercializando computadores cada vez más sofisticados,
evolucionando a tal grado la tecnología
de la información, hasta convertirse en lo que es hoy
en día.
- ORGANIZACIÓN FISICA DEL COMPUTADOR (HARDWARE)
El computador, habiendo sido diseñado para el
procesamiento de
datos, su organización es similar a la de cualquier
otro proceso. Indiferente de lo que se desee procesar,
siempre se tendrán tres elementos importantes, la materia prima,
la transformación que es el proceso en
sí, y el producto final , es decir la materia
prima transformada en un nuevo producto. Así, el computador está
conformado por dispositivos de entrada, unidad central de
procesamiento, dispositivos de salida y adicionalmente memoria externa o dispositivos de almacenamiento.
Dispositivos de entrada
Estos son, teclado,
ratón, escáner,
micrófono, entre muchos otros, todos ellos permiten entrar
datos al sistema. Los datos son transformados en señales
eléctricas y almacenados en la memoria
central, donde permanecerán disponibles para ser
procesados o almacenados en medios de
almacenamiento
permanente.
Unidad central de procesamiento
Comúnmente se la conoce como CPU, que
significa Central Processing unit, ésta es
quizá la parte más importante del computador, ya
que en ella se encuentra la unidad de control y la
unidad aritmético-lógica, las cuales en
constante interacción con la memoria principal
(también conocida como memoria interna) permiten manipular
y procesar la información, y controlar los demás
dispositivos de la unidad computacional.
Memoria externa
También se la conoce como memoria auxiliar, ésta es la encargada de brindar seguridad a la información almacenada, por cuanto guarda los datos de manera permanente e independiente
de que el computador esté en funcionamiento, a diferencia de la
memoria interna que solo mantiene la información mientras el equipo
esté encendido. Los dispositivos de almacenamiento son discos y cintas
principalmente, los discos pueden ser flexibles, duros u ópticos.
Disco Magnético: es una superficie plana circular, puede ser plástica o metálica, recubierta con oxido de hierro.
La superficie recubierta es magnetizada formando puntos
microscópicos, cada uno de los cuales actúa como un pequeño imán
permanente. Según la polarización de los puntos la señal puede indicar falso o verdadero, 0 o 1.
Los puntos se disponen en forma de líneas
concéntricas que reciben el nombre de pistas y se numeran desde 0 comenzando desde el exterior . Para poder
establecer las direcciones en que se almacena la
información, es necesario trazar líneas en sentido
perpendicular a las pistas, estas se denominan sectores y dividen
el disco en forma similar a como se cortan las rebanadas de un
pastel. Cada sector tiene una dirección única en el disco.
El proceso de
trazado de pistas y sectores en un disco se denomina
formatear que equivale a preparar el disco para que pueda
almacenar información de manera confiable.
Discos
flexibles: comúnmente están
fabricados en material plástico y tienen la particularidad de que pueden ser introducidos y retirados de la unidad de disco o
Los discos flexibles tienen la desventaja que pueden dañarse con facilidad, por ello es importante tener en cuenta algunos cuidados , como son:
- No doblarlos, ni arquearlos
- No presionarlos
- No acercarlos a campos magnéticos
Discos duros: a diferencia de los discos
flexibles, estos están hechos generalmente de aluminio,
giran a una velocidad 10 veces mayor y su capacidad de
almacenamiento es muy grande (40 gigabytes). Un disco duro es un paquete herméticamente cerrado, conformado por varios discos o placas, sus respectivas cabezas de lectura/escritura y la unidad de disco. El disco duro constituye el medio de almacenamiento más importante de un computador, ya que en la actualidad , por los volúmenes de información que se maneja, es muy difícil trabajar sin éste.
CD-ROM: disco compacto de solo lectura. Estos discos forman parte de la
Dispositivos de salida
Permiten presentar los resultados del procesamiento de datos, son
el medio por el cual el computador presenta información a los
usuarios. Los más comunes son la pantalla y la impresora.
Pantalla o monitor:
exhibe las imágenes
que elabora de acuerdo con el programa o proceso que se esté ejecutando, puede ser videos , gráficos, fotografías o texto. Es la
salida por defecto donde se presentan los mensajes generados por
el computador, como errores, solicitud de datos, etc.
Hay dos grandes clasificaciones de los monitores: los monocromáticos que presentan la información en gama de grises y lo policromáticos o monitores a color que pueden
utilizar desde 16 colores hasta
colores reales.
Los monocromáticos son cada vez menos usados, sin embargo
aun quedan muchos de este tipo en el mercado.
En los monitores de color existen dos tipos, los VGA y los SVGA
(superVGA). Estas características determinan la cantidad de colores
que pueden reproducir y la resolución o nitidez.
Toda pantalla está formada por puntos de luz
llamados pixeles que se iluminan para dar forma a las imágenes y a
los caracteres. Cuantos más pixeles tenga una pantalla mejor es su
resolución, por eso se habla de pantallas de 640 x 480, de 600x800 y de 1280 x 1024, siendo las últimas las de mayor nitidez.
La distancia existente entre los puntos se conoce como
dot pitch y es inversamente proporcional a la resolución
de la pantalla, entre menor sea la distancia entre puntos, mejor
es la imagen. En el mercado se escucha ofertas de equipos
con pantalla superVGA punto 28, esto significa que la pantalla es de
tipo SPVGA y que la distancia entre puntos es de 0.28 mm.
Impresora: fija sobre el papel la
información que se tiene en pantalla, en archivo o el resultado de un proceso. La impresión puede ser en negro o en colores según el tipo de
Hay tres grupos de
impresoras:
las de matriz de
puntos, las de burbuja y las laser. Las primeras son las más antiguas, son ruidosas y lentas, pero muy resistentes y económicas .
Se llaman de matriz de puntos porque forman los caracteres mediante
puntos marcados por los pines del cabezote. Hasta hace poco eran muy
económicas, pero en la actualidad, algunas series , son mucho más costosas que las impresoras de otros tipos.
Las impresoras de burbuja, también se llaman de inyección de tinta, estas son silenciosas e imprimen hasta cinco páginas por minuto, la calidad de
impresión es muy buena, el costo de la
impresora es moderado, sin embargo el costo de la
impresión es alto. No son recomendables para trabajo
pesado.
Las impresoras láser trabajan como una fotocopiadora y producen imágenes de optima calidad, tienen un bajo nivel de ruido y son las más rápidas, las impresoras son costosas pero la impresión es económica . Son recomendables para trabajos gráficos profesionales .
Hasta el momento se ha centrado la atención en la parte física del
computador, ahora se presenta la parte intangible, que al igual
que la anterior, también está clasificada
según la función
que realiza.
- EL SOFTWARE
Como se anotó anteriormente, está conformado por toda la
información, ya sean instrucciones o datos, que hacen que el
computador funcione, sin el concurso de éste el hardware no realizar
ninguna función. El software está clasificado en cuatro grupos , según la tarea que realiza.
- SISTEMA OPERATIVO
Es un conjunto de programas indispensable para que el computador funcione. Estos se encargan de administrar todos los recursos de la
unidad computacional y facilitan la
comunicación con el usuario.
El sistema operativo
cuenta con programas especializados para diversas tareas, como
son la puesta en marcha del equipo, la interpretación de
comandos, el
manejo de entrada y salida de información a través
de los periféricos, acceso a discos, procesamiento
de interrupciones, administración de memoria y procesador, entre
otros.
Algunos sistemas operativos conocidos son Windows , con versiones 95, 98, 2000, Mileniun y NT; DOS; Netware; Unix, Linux, entre
otros.
- SOFTWARE DE APLICACIÓN
Es un conjunto de programas diferente al software del
sistema, éstos se encargan de manipular la
información que el usuario necesita procesar, son
programas que desarrollan una tarea específica y cuya
finalidad es permitirle al usuario realizar su trabajo con
facilidad, rapidez, agilidad y precisión. Entre el
software de
aplicación se tiene varios grupos, como son: procesadores de
texto, hoja electrónica, graficadores, bases de datos,
agendas, programas de contabilidad,
aplicaciones matemáticas, entre otros, algunos ejemplos
son: Word, Excel, Acces,
Corel.Draw, Foxpro, Trident,
etc
- LENGUAJES DE PROGRAMACION
En términos coloquiales, son programas que sirven
para crear otros programas. Al igual que el lenguaje
natural constan de sintaxis, semántica y vocabulario que
el computador puede entender y procesar.
Los lenguajes de
programación se clasifican en tres categorías:
lenguaje de
máquina, lenguaje de
bajo nivel y lenguaje de alto nivel. En la actualidad se utilizan
los últimos, cuyo vocabulario está formado por
términos en inglés,
como son: C++, Foxpro, Visual Basic,
Java, HTML
- PROGRAMACION EN C
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.
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;
};
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.
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:
amigo:
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
char edad;
};
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.
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;
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).
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;
int main()
{
printf( "Escribe el nombre del amigo: " );
struct estructura_amigo { /* Definimos la estructura
estructura_amigo */
char nombre[30];
char apellido[40];
char telefono[10];
char edad;
};
struct estructura_amigo amigo;
int 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 tomaria los espacios.
Se podría haber declarado directamente la variable amigo:
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 tomaria los espacios.
Se podría haber declarado directamente la variable amigo:
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
} 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
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. Veámoslo en un ejemplo en el que se
supone que tenemos que meter los datos de tres amigos:
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. Veámoslo en un ejemplo en el que se
supone que tenemos que meter los datos de tres amigos:
#include <stdio.h>
#define ELEMENTOS 3
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo[ELEMENTOS];
int main()
{
int num_amigo;
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
#define ELEMENTOS 3
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo[ELEMENTOS];
int 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 */
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
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 );
}
}
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 */
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
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 );
}
}
MPORTANTE: 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
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.
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 = {
definido antes sería por ejemplo:
struct estructura_amigo amigo = {
"Juanjo",
"Lopez",
"592-0483",
30
};
"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:
Por supuesto hemos de meter en cada campo el tipo de datos correcto. La
definición de la estructura es:
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
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.
(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.
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.
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.
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:
utiliza un puntero para acceder a la información de la estructura:
#include <stdio.h>
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo = {
"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 );
}
struct estructura_amigo {
char nombre[30];
char apellido[40];
char telefono[10];
int edad;
};
struct estructura_amigo amigo = {
"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;
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...'.
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 ...".
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:
en las estructuras. Lo vamos a ver un ejemplo:
#include <stdio.h>
struct estructura_amigo {
char nombre[30];
char apellido[40];
int edad;
};
struct estructura_amigo amigo, *p_amigo;
int main()
{
p_amigo = &amigo;
/* Introducimos los datos mediante punteros */
printf("Nombre: ");fflush(stdout);
struct estructura_amigo {
char nombre[30];
char apellido[40];
int edad;
};
struct estructura_amigo amigo, *p_amigo;
int 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( "%s tiene ", p_amigo->apellido );
printf( "%i años.\n", p_amigo->edad );
}
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( "%s tiene ", p_amigo->apellido );
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 &.
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.
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
struct estructura_amigo {
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;
int main()
{
int num_amigo;
p_amigo = amigo; /* apuntamos al primer elemento del array */
/* Ahora imprimimos sus datos */
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf( "El amigo %s ", p_amigo->nombre );
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 );
/* y ahora saltamos al siguiente elemento */
p_amigo++;
}
}
#define ELEMENTOS 3
struct estructura_amigo {
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;
int main()
{
int num_amigo;
p_amigo = amigo; /* apuntamos al primer elemento del array */
/* Ahora imprimimos sus datos */
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf( "El amigo %s ", p_amigo->nombre );
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 );
/* 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.
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:
estructuras mediante punteros:
#include <stdio.h>
#define ELEMENTOS 3
struct estructura_amigo {
char nombre[30];
char apellido[40];
int edad;
};
struct estructura_amigo amigo[ELEMENTOS], *p_amigo;
int 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 %i\n",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++;
}
/* Ahora imprimimos sus datos */
p_amigo = amigo;
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf( "El amigo %s ", p_amigo->nombre );
printf( "%s tiene ", p_amigo->apellido );
printf( "%i años.\n", p_amigo->edad );
p_amigo++;
}
}
#define ELEMENTOS 3
struct estructura_amigo {
char nombre[30];
char apellido[40];
int edad;
};
struct estructura_amigo amigo[ELEMENTOS], *p_amigo;
int 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 %i\n",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++;
}
/* Ahora imprimimos sus datos */
p_amigo = amigo;
for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ )
{
printf( "El amigo %s ", p_amigo->nombre );
printf( "%s tiene ", p_amigo->apellido );
printf( "%i años.\n", p_amigo->edad );
p_amigo++;
}
}
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í:
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];
};
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_proveedor[40];
char telefono_proveedor[10];
char direccion_proveedor[100];
};
struct estruc_inventario {
char titulo[30];
char autor[40];
struct estruc_existencias existencias;
struct estruc_proveedor proveedor;
} inventario;
más ordenada:
struct estruc_existencias {
int discos;
int cintas;
int cd;
};
struct estruc_proveedor {
char nombre_proveedor[40];
char telefono_proveedor[10];
char direccion_proveedor[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
inventario.existencias.cd
y para acceder al nombre del proveedor:
inventario.proveedor.nombre
