Guía No.

2
Estructura Dinámica de datos con funciones

Conociendo ya la manera de declarar, inicializar, capturar y presentar una estructura dinámica de datos
(registro), se verá a continuación cómo se llevan a cabo las dos últimas tareas (captura y presentación) mediante
funciones.
Igualmente, el manejo de funciones para una estructura dinámica requiere de las características de prototipado,
declaración, desarrollo o cuerpo y por último, la presentación.

1. Prototipado de funciones para manejar una estructura dinámica de datos:

//Prototipado de las funciones

void capturar_registro(ptrUsuario *User1, int dato_id1, float dato_salario1);
void presentar_registro(ptrUsuario User2);

La funciones se prototipan antes de la declaración de la función principal (main) y como manejan apuntadores de
tipo estructura, no retornan ningún resultado cuando son invocadas; por lo cual estas se definen de tipo “void”.
La función “capturar_registro” posee tres parámetros a saber:
El primer parámetro es un apuntador de tipo estructura llamado “ptrUsuario”; su nombre es “User1” y se le
coloca como prefijo el símbolo asterisco (*) para denotar que es un apuntador. Este parámetro contendrá la
dirección de memoria de la estructura creada en tiempo de ejecución, para asignarle posteriormente ya
dentro de la función, los datos a los miembros de dicha estructura dinámica.
El segundo parámetro es una variable de tipo de dato entero llamada “dato_id1”, la cual va a almacenar
temporalmente el dato de la identificación del empleado (ingresado por el usuario final desde el teclado),
para posteriormente ya dentro de la función, asignar su contenido al primer miembro de la estructura
dinámica.
El tercer y último parámetro es una variable de tipo de dato real cuyo nombre es “dato_salario1”, la cual va a
almacenar temporalmente el dato del salario del empleado (ingresado por el usuario final desde el teclado),
para posteriormente ya dentro de la función, asignar su contenido al segundo miembro de la estructura
dinámica
La función “presentar_registro” posee solamente un parámetro llamado “User2” de tipo estructura “ptrUsuario”.
Dado que no se trabajará la estructura para acceder a su contenido sino para leerlo unicamente, no es necesario
crear un apuntador para dicha labor de presentación; por esto el nombre del parámetro carece del símbolo “*”
como prefijo.

2. Declaración de la función de captura de datos para una estructura dinámica

//Función de captura de los datos de una estructura dinámica

void capturar_registro(ptrUsuario *User1, int dato_id1, float dato_salario1){

} //Cierre función capturar_registro

La función de captura de datos se declara posterior a la función principal (main), la cual coincide con el
prototipado de la misma con la salvedad de cambiar el símbolo “ ; ” de terminación de la instrucción por un
juego de llaves “ {} ”, para ubicar posteriormente dentro de ellas el desarrollo de la función en cuestión.
3. Desarrollo o cuerpo de la función de captura de datos para una estructura dinámica

//Función de captura de los datos de una estructura dinámica

void capturar_registro(ptrUsuario *User1, int dato_id1, float dato_salario1){
//Declaración de un apuntador tipo estructura dinámica
ptrUsuario ptrNuevo;

//Asignación de los datos al apuntador de la estructura dinámica

ptrNuevo->id = dato_id1;
ptrNuevo->salario = dato_salario1;

//Asignación del apuntador a la estructura dinámica

*User1 = ptrNuevo;

} //Cierre función capturar_registro

El desarrollo de la función de captura de datos requiere de declarar un apuntador de alcance local (se conoce
también como apuntador temporal)de tipo estructura, ello con el fin de manipular los datos que el usuario
ingresó desde teclado sin propensión a errores. Dicha declaración del apuntador local corresponde a la
instrucción: “ptrUsuario ptrNuevo;”.
A continuación se asignan los datos al apuntador temporal desde los parámetros “dato_id1” y “dato_salario1” en
sus correspondientes miembros (id y salario), mediante el uso del operador apuntador (->). Dicha asignación de
datos corresponde a las instrucciones “ptrNuevo->id = dato_id1;” y “->salario = dato_salario1;”.
Por último, teniendo los datos ya asignados en los miembros “id” y “salario” en el apuntador de alcance local
“ptrNuevo”, se asigna entonces dicho apuntador de tipo estructura al parámetro “*User1”, también de tipo
estructura, cuyo contenido es la dirección de memoria creada en tiempo de ejecución y la cual fue transferida en
el momento de la invocación de la función de captura (la cual se detalla en el siguiente inciso). Dicha asignación
del apuntador corresponde a la instrucción “*User1 = ptrNuevo;”.

4. Invocación de la función de captura de datos para una estructura dinámica

//Asignación de los datos al registro

capturar_registro(&Cliente, dato_id, dato_salario);

La invocación de la función “capturar_registro” posee tres argumentos a saber:

El primer argumento atañe a la dirección de memoria creada en tiempo de ejecución y cuyo nombre es “Cliente”,
mas para poderla transferir a la función se ha de colocarle como prefijo el símbolo “&”. A dicha estructura se le
asignarán, ya en el interior de la función, los datos capturados desde teclado en sus correspondientes miembros
(id y salario).
El segundo argumento corresponde al dato de identificación del empleado capturado desde teclado al usuario
final, el cual se ha declarado con antelación como variable global al interior de la función principal.
El tercer y último argumento corresponde al dato de salario del empleado capturado desde teclado al usuario
final, el cual igualmente, se ha declarado con antelación como variable global al interior de la función principal.
5. Declaración de de la función de presentación de datos para una estructura dinámica

//Función de presentación de una estructura dinámica

void presentar_registro(ptrUsuario User2){

} //Cierre función presentar_registro

La función de presentación de datos se declara posterior a la función de captura, la cual coincide con el
prototipado de la misma con la salvedad de cambiar el símbolo “ ; ” de terminación de la instrucción por un
juego de llaves “ {} ”, para ubicar posteriormente dentro de ellas el desarrollo de la función en cuestión.

6. Desarrollo o cuerpo de la función de presentación de datos para una estructura dinámica

//Función de presentación de una estructura dinámica

void presentar_registro(ptrUsuario User2){
printf("\nId: %d", User2->id);
printf("\nSalario: %f", User2->salario);
} //Cierre función presentar_registro

El desarrollo de la función de presentación de datos atañe a un par de instrucciones:

La primera instrucción consiste en la visualización en pantalla de la identificación del empleado, la cual se
efectúa accediendo al miembro “id” en la estructura dinámica “User2” recibida como parámetro en la función
desde la invocación de la misma (la cual se detalla en el siguiente inciso). El acceso en cuestión se lleva a cabo
mediante el uso del operador apuntador (->) por lo que la instrucción queda como sigue: printf("\nId: %d",
User2->id);
La segunda y última instrucción se refiere a la observación del salario del empleado, el cual se realiza
accediendo al miembro “salario” en la estructura dinámica “User2” recibida como parámetro en la función desde
la invocación de la misma (la cual se detalla en el siguiente inciso). El acceso en cuestión se lleva a cabo
mediante el uso del operador apuntador (->) por lo que la instrucción queda como sigue: printf("\nSalario: %f",
User2->salario);

7. Invocación de la función de captura de datos para una estructura dinámica

//Presentación del contenido de la estructura dinámica

printf("\nCONTENIDO DE UNA ESTRUCTURA DINAMICA O REGISTRO DE DATOS...\n");
presentar_registro(Cliente);

La invocación de la función “capturar_registro” posee un sólo argumento, el cual atañe a la estructura dinámica
creada en tiempo de ejecución y cuyo nombre es “Cliente”. Su transferencia requiere únicamente del nombre, ya
que se está trabajando directamente con la memoria asignada de manera dinámica.

…………………………………..
El código fuente completo de una aplicación que implementa una estructura dinámica de datos desde su
prototipado, declaración, inicialización, captura y presentación mediante funciones, se desarrolla a continuación:

/*Captura y presentación de los datos de un cliente

haciendo uso de un registro o estructura con funciones
L16/05/2016 - 07:12 - MOBA*/

#include <stdio.h>
#include <stdlib.h>

//Prototipado de un registro o estructura dinámica

struct empleado{
int id;
float salario;
};

//Definición de un alias para la estructura empleado

typedef struct empleado Usuario;

//Definición de un alias para un apuntador a la estructura empleado

typedef Usuario *ptrUsuario;

//Prototipado de las funciones

void capturar_registro(ptrUsuario *User1, int dato_id1, float dato_salario1);
void presentar_registro(ptrUsuario User2);

int main(){

//Declaración de una estructura dinámica

ptrUsuario Cliente;

//Declaración de variables para la captura de datos

int dato_id; float dato_salario;

//Inicialización de una estructura dinámica

Cliente = NULL;

//Inicialización de variables de captura de datos

dato_id = 0; dato_salario = 0,0;

//Asignación de memoria a la estructura de manera dinámica

Cliente = (Usuario *)malloc(sizeof(Usuario));

//Inicialización de las variables de la estructura

Cliente->id = 0;
Cliente->salario = 0,0;
 //Captura de datos desde teclado
printf("\nINGRESO DE DATOS DE UN CLIENTE...\n");
printf("\nId: ");
scanf("%d", &dato_id);
printf("\nSalario: ");
scanf("%f", &dato_salario);

//Asignación de los datos al registro

capturar_registro(&Cliente, dato_id, dato_salario);

//Presentación del contenido de la estructura dinámica

printf("\nCONTENIDO DE UNA ESTRUCTURA DINAMICA O REGISTRO DE DATOS...\n");
presentar_registro(Cliente);

printf("\n\n");
system("PAUSE");
return 0;

} //Cierre función principal

//Función de captura de los datos de una estructura dinámica

void capturar_registro(ptrUsuario *User1, int dato_id1, float dato_salario1){
//Declaración de un apuntador tipo estructura dinámica
ptrUsuario ptrNuevo;

//Asignación de los datos al apuntador de la estructura dinámica

ptrNuevo->id = dato_id1;
ptrNuevo->salario = dato_salario1;

//Asignación del apuntador a la estructura dinámica

*User1 = ptrNuevo;

} //Cierre función capturar_registro

//Función de presentación de una estructura dinámica

void presentar_registro(ptrUsuario User2){
printf("\nId: %d", User2->id);
printf("\nSalario: %f", User2->salario);
} //Cierre función presentar_registro

Con el fin de apropiarse del concepto descrito, se recomienda construir línea por línea la aplicación anterior y
así, poder trabajar posteriormente la gestión de diversas estructuras dinámicas de datos en conjunto, cuyo
nombre es “Listas” y la cual se detallará en la siguiente guía.