Registros o Estructuras (STRUCT)

En C, una estructura o registro es un conjunto de variables, del mismo tipo o no, agrupadas bajo un mismo nombre,
con fin de facilitar el trabajo con ellas. A cada dato dentro de la estructura la llamamos miembro, campo o elemento.

1 Declaración de estructuras

La declaración de una estructura se hace de la siguiente manera:

struct nombre_estructura
{
tipo1 dato1;
tipo2 dato2;
...
tipoN datoN;
};

Supongamos que queremos hacer una agenda con el número de teléfono y la edad de una persona. Sin el uso de
estructuras, el programa quedaría desordenado y difuso. Pero gracias a esta opción que nos permite C, el problema
se simplifica. Aquí el ejemplo de la declaración de la estructura:

struct estructura_persona

{
char nombre[30];

char apellido[40];
char telefono[10];
char edad;
};

Una vez definida la estructura, podemos usarla declarando una variable con esa estructura:
struct estructura_persona amigo;

Ahora la variable amigo es de tipo estructura_persona.

Definir la estructura Datos_Personales, declaré otras variables a partir de esta estructura

2 Acceder a los campos de la estructura

Para acceder a los campos de la estructura, lo haremos de la manera siguiente:

variable.campo;

Donde variable es el nombre de la variable de tipo estructura que hemos creado, y campo es el nombre de la variable
que forma parte de la estructura. Lo veremos mejor con un ejemplo basado en la estructura definida anteriormente:

amigo.edad=27;

Con esta sentencia lo que estamos haciendo es almacenar el valor 27 en el campo edad de la variable amigo.

Una opción que nos permiten las estructuras es pasar el contenido de una estructura a otra, siempre que sean del
mismo tipo naturalmente. Por ejemplo, si hemos declarado las estructuras del mismo tipo persona1 y persona2,
podemos asignarle los datos almacenados en todos los campos de la estructura persona1, a la persona2 de la
siguiente manera:

persona2=persona1;

3 Array de estructuras

Supongamos ahora que queremos guardar la información de varias personas. Con una variable de estructura sólo
podemos guardar los datos de uno. Necesitamos declarar arrays de estructuras:
struct estructura_persona amigo[10];

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.

Ejemplo
Desarrollar un programa que permita implementar un menú para realizar las siguientes operaciones sobre el
vector de registro ventas, para un grupo de 10 vendedores. Se debe definir una función para cada una de las
siguientes opciones las cuales se deben visualizar a través de un menú.
1. Cargar vector: llenar el vector con los datos de cada vendedor
2. Calcular venta: calcular la venta total del vendedor
3. Ordenar vector ascendentemente por el nombre
4. Visualizar vector de registro
5. Salir

Por cada vendedor se tiene la siguiente información: nombre, valor artículo, cantidad vendida y venta total.
Solución.
#include <iostream.h>
#include <string.h>
# define n 3

struct venta{
char nombre[50];
long total_vendido;
long valor_art;
int cantidad;
};

venta Vector_venta[n]; //declaración del vector de registro con las mismas características de la estructura venta.

int principal_menu();
void cargar();
void calcular();
void ordenar();
void visualizar();

int main (){

int opc;
for(;;){
opc = principal_menu();//retorna la opción escogida por el usuario
switch (opc){
case 1: cargar(); break;
case 2: calcular(); break;
case 3: ordenar(); break;
case 4: visualizar(); break;
case 5: exit(0);
}
}
return 0;
}

int principal_menu(){
int opc;
do{
cout<<"Menu Operaciones sobre el Vector de Registro" <<endl;
cout<<"1. Cargar Vector de Registro" <<endl;
cout<<"2. Calcular Venta " <<endl;
cout<<"3. Ordenar Vector de Registro" <<endl;
cout<<"4. Visualizar Vector de Registro" <<endl;
cout<<"5. Salir " <<endl;
cout<<"Seleccione una opción: ";
cin>>opc;
}while(opc<1 || opc>5);
return opc;
}
void cargar(){ //función para llenar el vector de registro
int x;
for(x=0;x<n;x++){//ciclo para llenar los campos de cada posición del vector
cout<<"Cargando datos del vendedor: " <<x+1 <<endl;
cout<<"Nombre: ";
fflush(stdin); // libera el buffer del teclado antes de leer la cada cadena.
gets(Vector_venta[x].nombre);
cout<<"Valor del articulo: ";
cin>>Vector_venta[x].valor_art;
cout<<"Cantidad Vendida: ";
cin>>Vector_venta[x].cantidad;
}

void calcular(){ /*función para calcular el total vendido y asignarlo en el campo correspondiente de cada posición
del vector de registro*/
cout<<"Calculando venta de los vendedores ";
for(int x=0; x<n; x++)
Vector_venta[x].total_vendido = Vector_venta[x].valor_art * Vector_venta[x].cantidad;

void visualizar(){//función que imprime la información almacenada en el vector de registro

for(int x=0; x<n ; x++){
cout<<"Nombre: " <<Vector_venta[x].nombre <<endl;
cout<<"Valor Unitario " <<Vector_venta[x].valor_art <<endl;
cout<<"Cantidad Vendida " <<Vector_venta[x].cantidad <<endl;
cout<<"Total Vendido " <<Vector_venta[x].total_vendido <<endl;
}
system("pause");

void ordenar(){ /*función para ordenar el vector de registro ascendentemente por el campo nombre*/
venta aux; /*variable auxiliar para odenar el vector de registro del tipo de la estructura de venta */

for(int x=0; x<n-1; x++)

for(int y=x+1; y<n; y++)
if(strcmp(Vector_venta[x].nombre,Vector_venta[y].nombre)>0){ /*comparamos las cadenas si el
nombre que está en la posición x es mayor que lo que está en y lo asignamos a la variable aux luego
pasamos el nombre menor a la posición de x y luego al campo de la posición y asignamos el nombre
más grande*/
aux = Vector_venta[x];
Vector_venta[x] = Vector_venta[y];
Vector_venta[y] = aux;
}

}
Actividad en Clase

1. Crear un vector de registro para n empleados, se debe ingresar desde teclado utilizando el
nombre, las horas trabajadas, valor de la hora. la edad, el sueldo.

Sabiendo que cuando las horas de trabajo exceden de 40, el resto se considera horas extras y que
éstas se pagan al doble de una hora normal cuando no exceden de 8; si las horas extras exceden de
8 se pagan las primeras 8 al doble de lo que se paga una hora normal y el resto al triple.

Crear un menú con las siguientes opciones, definiendo una función para cada opción.
a) Ingresar datos: Ingresa los datos en el vector
b) Calcular: calcular el salario por concepto de horas extras, horas ordinarias
c) Consultar : Se debe visualizar el vector de registro ordenado
 ascendente por nombre y el total de la nómina cancelado por la empresa
 descendentemente por total horas extras con el promedio de horas extras cancelado por
la empresa