declaraciÓn de tipos propios (estructuras y uniones… · declaraciÓn de tipos propios...

DECLARACIÓN DE TIPOS PROPIOS (ESTRUCTURAS Y UNIONES)

EN C

2010 UNAN – LEÓN

Departamento de Computación Autor: Ing: Karina Esquivel Alvarado. Asignatura: PROGRAMACIÓN ESTRUCTURADA

Declaración de Tipos Propios en C

2

ESTRUCTURAS EN C � INTRODUCCIÓN: La capacidad para crear nuevos tipos es una característica importante y potente de C y libera a un programador de restringirse al uso de los tipos ofrecidos por el lenguaje. Una estructura contiene múltiples variables, que pueden ser de tipos diferentes. La estructura es importante para la creación de programas potentes, tales como bases de datos u otras aplicaciones que requieran grandes cantidades de datos. � ESTRUCTURAS: Los arrays son estructuras de datos que contienen un número determinado de elementos y todos los elementos han de ser del mismo tipo de datos; es una estructura homogénea. Esta característica supone una gran limitación cuando se requieren grupos de elementos con tipos diferentes de datos cada uno. Por ejemplo, si se dispone de una lista de temperaturas, es muy útil un array, sin embargo, si se necesita una lista de información de clientes que contengan elementos tales como: el nombre, edad, dirección, número de cédula, etc., los arrays no son adecuados. La solución a este problema es utilizar un tipo de dato registro, en C llamado “estructura”. Una estructura puede contener cualquier número de miembros, cada uno tiene un nombre único, denominado nombre del miembro. “Una estructura es una colección de uno o más tipos de elementos denominados miembros,

cada uno de los cuales puede ser de un tipo de dato diferente”.

Ejemplo: Supongamos que se desea almacenar los datos de una colección de discos compactos (colección_CD) de música. Estos datos pueden ser:

� Título. � Artista. � Número de canciones. � Precio. � Fecha de Compra.

La estructura colección_CD contiene cinco miembros. Tras decidir los miembros, se debe decidir cuáles son los tipos de datos para utilizar por los miembros. Esta información se representa en la siguiente tabla:


3

Nombre Miembro Tipo de Dato Título Array de Caracteres de tamaño 30. Artista Array de Caracteres de tamaño 25. Número de Canciones Entero. Precio Coma Flotante. Fecha de Compra Array de Caracteres de tamaño 8

Una estructura es un tipo de datos definido por el usuario, que se debe declarar antes de que se pueda utilizar. El formato de la declaración es: struct <nombre de la estructura> { <tipo de dato miembro1> <nombre miembro1> <tipo de dato miembro2> <nombre miembro2> <tipo de dato miembro3> <nombre miembro3> …………….. <tipo de dato miembron> <nombre miembron> }; Por ejemplo: La declaración de la estructura colección_CD es: struct colección_CD { char titulo [30]; char artista [25]; int num_canciones; float precio_cd; char fecha_compra [8]; }; Por ejemplo: La declaración de la estructura venta es: struct venta { char vendedor[30]; unsigned int codigo; int cant_articulos; float precio_unit; };


4

� DEFINICIÓN DE VARIABLES DE ESTRUCTURAS: A una estructura se accede utilizando una variable o variables que se deben definir después de la declaración de la estructura. Del mismo modo que sucede en otras situaciones, en C existen dos conceptos similares a considerar, declaración y definición. La diferencia técnica es la siguiente, una declaración especifica simplemente el nombre y el formato de la estructura de datos, pero no reserva almacenamiento en memoria; la declaración especifica un nuevo tipo de dato: struct <nombre-estructura>. Por consiguiente, cada definición de variable para una estructura dada crea un área en memoria en donde los datos se almacenan de acuerdo al formato estructurado declarado. Las variables de estructuras se pueden definir de dos formas:

1. Listándolas inmediatamente después de la llave de cierre de la declaración de la estructura.

2. Listando el tipo de la estructura creada por las variables correspondientes en cualquier lugar del programa antes de utilizarlas.

La definición y declaración de la estructura “coleccion_CD” se puede hacer por cualquiera de los dos métodos:

1. struct coleccion_CD { char titulo [30]; char artista [25]; int num_canciones; float precio_cd; char fecha_compra [8]; } cd1, cd2, cd3;

2. struct coleccion_CD cd1, cd2, cd3; Otros ejemplos de definición/declaración: Considerar un programa que gestione libros y procese los siguientes datos: título del libro, nombre del autor, editorial y año de publicación.


5

Una estructura info_libro podría ser: struct info_libro { char titulo_lib [50]; char autor [30]; char editorial [30]; int anyo; }; La definición de la estructura se puede hacer así:

1. struct info_libro { char titulo_lib[50]; char autor[30]; char editorial[30]; int anyo; } libro1, libro2, libro3;

2. struct info_libro libro1, libro2, libro3; � INICIALIZACIÓN DE UNA DECLARACIÓN DE ESTRUCTURAS: Una estructura se puede inicializar de dos formas: ♦ Dentro de la sección de código de su programa. ♦ Como parte de la definición de la estructura, especificando los valores iniciales, entre

llaves, después de la definición de variables estructura. El formato general en este caso es: struct <tipo> <nombre variable estructura > {

valor miembro1, valor miembro2, ………………… valor miembron

} = variable_estructura {datos de inicialización};


6

Ejemplo #1: Este programa imprime el valor de una variable de tipo struct info_libro que fue inicializada durante la declaración. //inicia_struct.c #include<stdio.h> struct info_libro { char titulo_lib [50]; char autor [30]; char editorial [30]; int anyo; } libro1 = {"Programacion en C","Luis Joyanes Aguilar", "McGraw-Hill",2001}; void main() { printf("Titulo del libro: %s\n",libro1.titulo_lib); printf("Autor del libro: %s\n",libro1.autor); printf("El Libro fue Editado en: %s\n",libro1.editorial); printf("Anyo de la Edicion es: %d\n",libro1.anyo); } Salida:

� TAMAÑO DE UNA ESTRUCTURA: El operador sizeof se aplica sobre un tipo de datos, o bien sobre una variable. Se puede aplicar para determinar el tamaño que ocupa en memoria una estructura. El siguiente programa ilustra el uso del operador sizeof para determinar el tamaño de una estructura: Ejemplo #2: Este programa permite visualizar el tamaño en bytes de una estructura. //tamanyo_struct.c #include <stdio.h> /*declarar una estructura Persona*/ struct persona { char nombre [30]; int edad;


7

float altura; float peso; }; void main( ) { struct persona per; printf ("El Tamanyo en Bytes de struct(persona) es: %d\n",sizeof(per)) ; } Salida:

� ACCESO A ESTRUCTURAS: Se puede acceder a los miembros de una estructura de dos formas:

� Utilizando el operador punto (.). � Utilizando el operador puntero ->.

� LECTURA Y RECUPERACIÓN DE INFORMACIÓN DE UNA ESTRUCTURA: Se puede almacenar información en una estructura mediante inicialización, asignación directa o lectura del teclado. � ACCESO A UNA ESTRUCTURA DE DATOS MEDIANTE EL OPERADOR PUNTO: La asignación de datos a los miembros de una variable estructura se puede hacer mediante el operador punto. La sintaxis C es la siguiente: <Nombre variable estructura>.<Nombre miembro de la estructura> = datos; Ejemplos: strcpy(libro1.titulo_lib,”C-C++”); strcpy(libro1.autor,”Francisco Javier Ceballos”); strcpy(libro1.editorial,”RA-MA”); libro1.anyo= 2002;


8

El operador punto proporciona el camino directo al miembro correspondiente. Los datos que se almacenan en un miembro dado deben ser del mismo tipo que el tipo declarado para ese miembro. Ejemplo #3: Este programa lee del teclado los datos de una variable de tipo estructura llamada “corredor” y los visualiza. Utilizando el operando punto para acceder a los datos miembros de la estructura. //leer_struct.c #include<stdio.h> #include<string.h> struct corredor { char nombre[30]; char sexo[10]; char clubnom[25]; char categoria[12]; int edad; }; void main() { struct corredor c1; printf("Nombre Corredor: "); scanf("%s",&c1.nombre); fflussh(stdin); printf("Edad: "); scanf("%d",&c1.edad); printf("Sexo Corredor: "); scanf("%s",c1.sexo); printf("Nombre del Club: "); scanf("%s",&c1.clubnom); if(c1.edad <= 18) strcpy(c1.categoria,"Juvenil"); else if(c1.edad <= 40) strcpy(c1.categoria,"Adulto"); else strcpy(c1.categoria,"Veterano");


9

printf("\n****DATOS DEL CORREDOR****\n"); printf("Nombre Corredor:%s\n",c1.nombre); printf("Edad Corredor:%d\n",c1.edad); printf("Sexo Corredor:%s\n",c1.sexo); printf("Nombre Club:%s\n",c1.clubnom); printf("Categoria Corredor:%s\n",c1.categoria); } Ejemplo de Salida:

Ejemplo #4: Este programa lee del teclado los datos de una variable tipo struct llamada “estudiante”, calcula e imprime el promedio de las 5 calificaciones de un estudiante. //struct_estudiante.c #include<stdio.h> #include<string.h> struct estudiante { char nombre[30]; char num_carne[11]; int nota[5]; }; void main() { struct estudiante est; int n, sum=0; float prom; printf("Nombre Estudiante: "); gets(est.nombre); printf("Numero de Carnet: "); fflush(stdin);


10

gets(est.num_carne); printf("***Las 5 calificaciones son***\n"); for(n=0;n<5;n++) { printf("Nota[%d]: ",n+1); scanf("%d",&est.nota[n]); sum += est.nota[n]; } prom=sum/5; printf("\n****DATOS DEL ESTUDIANTE****\n"); printf("Nombre:%s\n",est.nombre); printf("Numero de Carnet:%s\n",est.num_carne); printf("Promedio: %.f\n",prom); } Ejemplo de Salida:

� ACCESO A UNA ESTRUCTURA DE DATOS MEDIANTE EL OPERADOR PUNTERO “->” El operador puntero -> sirve para acceder a los elementos de la estructura a partir de un puntero. Para utilizar este operador se debe definir primero una variable puntero para apuntar a la estructura. A continuación, utilice el operador puntero para apuntar a un miembro dado. La asignación de datos a estructuras utilizando el operador -> tiene el siguiente formato: <Puntero Estructura> -> <Nombre miembro> = datos; Ejemplo #5: Este programa lee del teclado los datos de una variable de tipo estructura llamada “corredor” y los visualiza. Utilizando el operando puntero -> para acceder a los datos miembros de la estructura.


11

//leer_struct_2.c #include<stdio.h> #include<string.h> struct corredor { char nombre[30]; char clubnom[25]; char categoria[12]; char sexo; int edad; }; void main() { struct corredor c,*ptr_c; ptr_c=&c; printf("Nombre Corredor: "); gets(ptr_c->nombre); printf("Edad: "); fflush(stdin); scanf("%d",&ptr_c->edad); printf("Sexo Corredor (f - m): "); fflush(stdin); scanf("%c",&ptr_c->sexo); printf("Nombre del Club: "); fflush(stdin); gets(ptr_c->clubnom); if(ptr_c->edad <= 18) strcpy(ptr_c->categoria,"Juvenil"); else if(ptr_c->edad >=19 && ptr_c->edad<= 40) strcpy(ptr_c->categoria,"Adulto"); else strcpy(ptr_c->categoria,"Veterano"); printf("\n****DATOS DEL CORREDOR****\n"); printf("Nombre Corredor:%s\n",ptr_c->nombre); printf("Edad Corredor:%d\n",ptr_c->edad); printf("Sexo Corredor:%c\n",ptr_c->sexo); printf("Categoria Corredor:%s\n",ptr_c->categoria); printf("Nombre Club:%s\n",ptr_c->clubnom); }


12

Ejemplo de salida:

� ESTRUCTURAS ANIDADAS: Una estructura puede contener otras estructuras llamadas estructuras anidadas, las cuales ahorran tiempo en la escritura de programas que utilizan estructuras similares. Se han de definir los miembros comunes sólo una vez en su propia estructura y a continuación utilizar esa estructura como miembro de otra estructura. struct empleado { char nombre_emp[30]; char direccion[25]; char ciudad[20]; char provincia[20]; long int cod_postal; double salario; }; struct clientes { char nombre_cli[30]; char direccion[25]; char ciudad[20]; char provincia[20]; long int cod_postal; double saldo; }; Estas estructuras contienen datos diferentes aunque hay datos que están solapados. Así se podría crear una estructura info_dir, que contenga los miembros comunes.


13

struct info_dir { char direccion[25]; char ciudad[20]; char provincia[20]; long int cod_postal; }; Esta estructura se pude utilizar como miembro de las otras estructuras, es decir, anidarse. struct empleados { char nombre_emp[30]; struct info_dir domicilio_emp; double salario; }; struct clientes { char nombre_cli[30]; struct info_dir domicilio_emp; double saldo; };

Estructuras Anidadas

empleados:

nombre_emp

info_dir

salario

direccion

ciudad

provincia

cod_postal

clientes: nombre_cliente

info_dir

saldo

direccion

ciudad

provincia

cod_postal


14

Ejemplo #6: A partir de la declaración de las siguientes estructuras realice un programa en C que lea un dato de tipo “ats” y los imprima. struct datos_per {

char nombre[40]; char pais[25];

}; struct atleta {

char deporte[30]; int nmedallas; struct datos_per pers;

}; struct atleta ats; Solución: //atletas.c #include<stdio.h> struct datos_per { char nombre[40]; char pais[25]; }; struct atleta { char deporte[30]; int nmedallas; struct datos_per pers; }; struct atleta ats; void main() { printf("Nombre: "); scanf("%s",ats.pers.nombre);


15

printf("Pais: "); scanf("%s",ats.pers.pais); printf("Deporte: "); scanf("%s",ats.deporte); printf("Numero de Medallas: "); scanf("%d",&ats.nmedallas); printf("\n\t****DATOS DEL ATLETA****\n"); printf("NOMBRE: %s\n",ats.pers.nombre); printf("PAIS: %s\n",ats.pers.pais); printf("DEPORTE: %s\n",ats.deporte); printf("NUMERO DE MEDALLAS: %d\n",ats.nmedallas); } Ejemplo de Salida:

� ARRAYS DE ESTRUCTURAS: Se puede crear un array de estructuras tal como se crea un array de otros tipos. Los arrays de estructuras son idóneos para almacenar un archivo completo de empleados, un archivo de inventario o cualquier otro conjunto de datos que se adapte a un formato de estructura. Mientras que los arrays proporcionan un medio práctico de almacenar diversos valores del mismo tipo, los arrays de estructuras le permiten almacenar juntos diversos valores de diferentes tipos, agrupados como estructuras. “Para acceder a los miembros de cada uno de los elementos estructura se utiliza una notación de array”.


16

Ejemplo: struct info_libro libros[100]; /*Asigna un array de 100 elementos denominados libros*/ Para inicializar el primer elemento de “libros”, por ejemplo, su código debe hacer referencia a los miembros de libros[0] de la forma siguiente: strcpy(libros[0].titulo,”C-C++”); strcpy(libros[0].autor,”Francisco Ceballos”); strcpy(libros[0].titulo,”McGraw-Hill”); libros[0].anyo=1999; También puede inicializarse un array de estructuras en el punto de la declaración encerrando la lista de inicializadotes entre llaves {}. Por ejemplo: struct info_libro libros[2] = {“C++ a su alcence”,”Luis Joyanes”, “McGraw-Hill”,1999, “C”,”Francisco Ceballos”, “RA-MA”,2001, “Programación en C”,”Angel Hermoso”, “McGraw-Hill”,2000}; Ejemplo #7: Una librería desea catalogar su inventario de libros. El siguiente programa crea un array de 100 estructuras, donde cada estructura contiene diversos tipos de variables, incluyendo arrays. //inventario.c #include<stdio.h> #include<ctype.h> #include<stdlib.h> struct inventario { char titulo[25]; char fecha_pub[20]; char autor[30]; int num; }; void main() { struct inventario libro[30]; int total=0;


17

char resp; do { printf("Cual es el titulo del libro: "); gets(libro[total].titulo); printf("Cual es la fecha de publicacion: "); gets(libro[total].fecha_pub); printf("Autor del Libro: "); gets(libro[total].autor); printf("Cuantos libros existen: "); scanf("%d",&libro[total].num); fflush(stdin); printf("\n\nHay mas libros:(S/N)"); scanf("%c",&resp); fflush(stdin); resp=toupper(resp); if(resp=='S') { total++; continue; } }while(resp=='S'); printf("\n****TOTAL DE LIBROS: %d\n", (total+1)); }


18

Ejemplo de Salida:

Ejemplo #8: Este programa declara un array de estructuras Estudiante para conocer cuál es el estudiante que obtuvo la mayor nota. //nota_mayor.c #include<stdio.h> struct Estudiante { char nombre[30]; int nota; }; void main() { struct Estudiante est[20]; int i=1,j=1,pos,may; for(i=0;i<5;i++) { printf("Nombre Estudiante[%d]: ",i+1); gets(est[i].nombre); printf("Nota Estudiante[%d]: ",i+1); scanf("%d",&est[i].nota); fflush(stdin); } may=0; for(j=0;j<5;j++)


19

{ if(est[j].nota>may) { may = est[j].nota; pos = j; } } printf("\n%s ES QUIEN OBTUVO LA MAYOR NOTA:%d\n\n",est[pos].nombre,may); } Ejemplo de Salida:

� UTILIZACIÓN DE ESTRUCTURAS COMO PARÁMETROS DE UNA FUNCIÓN: C permite pasar estructuras a funciones, bien por valor o bien por referencia utilizando el operador &. Si la estructura es grande, el tiempo necesario para copiar un parámetro struct a la pila puede ser prohibitivo. En tales casos, se debe considerar el método de pasar la dirección de la estructura. Ejemplo #9: Este programa registra una estructura personaempleado que contiene como miembros los datos de una persona empleado que a su vez tenga los datos de la fecha de nacimiento. En un programa se muestra el uso de la estructura, se define una función para dar entrada a los datos de la estructura persona. A la función de entrada se transmite por dirección (&p) la variable estructura, por lo que el argumento correspondiente tiene que ser un puntero (*p) y el acceso a los campos se hace con el selector ->


20

//funcion_struct.c #include<stdio.h> #include<string.h> struct fecha { unsigned int dia, mes, anyo; }; struct persona { char nombre[30]; unsigned int edad; float peso; struct fecha fnac; }; struct persona_empleado { struct persona per1; unsigned int salario; }; /*PROTOTIPOS DE FUNCIONES*/ void EntradaDatos(struct persona_empleado *per); void MostrarDatos(struct persona_empleado per); void main() { struct persona_empleado p1; //Llamada a EntradaDatos() transmitiendo la dirección EntradaDatos(&p1); //Llamada a MostrarDatos() MostrarDatos(p1); } void EntradaDatos(struct persona_empleado *p) { printf("\n***LECTURA DE DATOS***\n"); printf("Introduzca el nombre: "); scanf("%s",p->per1.nombre);


21

printf("Introduzca la edad: "); fflush(stdin); scanf("%d",&p->per1.edad); printf("Peso: "); fflush(stdin); scanf("%f",&p->per1.peso); printf("Fecha de Nacimiento:DD MM AAAA: "); fflush(stdin); scanf("%d %d %d",&p->per1.fnac.dia,&p->per1.fnac.mes,&p->per1.fnac.anyo); printf("Salario: "); fflush(stdin); scanf("%d",&p->salario); } void MostrarDatos(struct persona_empleado p) { printf("\n***DATOS DEL EMPLEADO***\n"); printf("Nombre:%s\n",p.per1.nombre); printf("Edad:%d\n",p.per1.edad); printf("Peso:%.f\n",p.per1.peso); printf("Fecha Nacimiento: %d-%d-%d\n",p.per1.fnac.dia,p.per1.fnac.mes,p.per1.fnac.anyo); printf("Salario Mensual:%d\n",p.salario); } Ejemplo de Salida:


22

UNIONES EN C

� DEFINICIÓN DE UNIONES: Una unión es una región de almacenamiento compartida por dos o más miembros generalmente de diferentes tipos. Esto permite manipular diferentes tipos de datos utilizando una misma zona de memoria, la reservada para la variable “unión”. Las uniones son similares a las estructuras en cuanto que agrupa a una serie de variables, pero la forma de almacenamiento es diferente y por consiguiente, efectos diferentes. Una estructura permite almacenar variables relacionadas juntas y almacenadas en posiciones contiguas en memoria. Las uniones son declaradas con la palabra reservada “union”, almacenan miembros múltiples en un paquete; sin embargo, en lugar de situar sus miembros unos detrás de otros, en una unión, todos los miembros se solapan entre sí en la misma posición. El tamaño ocupado por una unión se determina así: es analizado el tamaño de cada variable de la unión el mayor tamaño de la variable será el tamaño de la unión. La sintaxis de una unión es la siguiente: union nombre { tipo1 miembro1; tipo2 miembro2; … };

Una declaración union define un tipo. La llave derecha que termina la lista de miembros puede ser seguida por una lista de variables de la siguiente manera:

Para acceder a un determinado miembro de una unión, se utiliza la notación: Variable_unión.miembro


23

Ejemplo: union PruebaUnion { float num1, num2; }; La cantidad de memoria reservada para una unión es igual a la anchura de la variable más grande. En el tipo union, cada uno de los miembros dato comparten memoria con los otros miembros de la unión. Ejemplo: union comparte { char letra; int elemento; float precio; double altura; }; La cantidad total de memoria utilizada por la unión comparte es de 8 bytes, ya que el elemento double es el miembro dato mayor de la unión. Una razón para utilizar una unión es ahorrar memoria. En muchos programas se deben tener varias variables, pero no necesitan utilizarse todas al mismo tiempo. Ejercicio #1: #include <stdio.h> typedef union { int a; int b; }prueba; void main(void) { prueba p1; p1.a = 10; p1.b = 100; printf("%d\n",p1.a);


24

printf("%d\n",p1.b); } Salida:

Este ejemplo define una unión p1 cuyos miembros a y b comparten un espacio de memoria de 4 bytes (suponiendo que un int ocupa 4 bytes). La ejecución es de la forma siguiente:

1. La sentencia p1.a=10 almacena en el espacio común el valor 10. 2. La sentencia p1.a=100 almacena en el espacio común el valor 100, sobrescribiendo el

valor anterior.

Ejercicio #2: #include <stdio.h> /* Definicion de la union numero*/ union numero { int x; double y; }; void main() { union numero valor; //define la variable union valor.x = 100; //coloca un entero dentro de la union printf("Coloca un valor en el miembro entero e imprime ambos miembros\n"); printf("int:%d double:%f\n",valor.x,valor.y ); valor.y = 100.0; //coloca un double dentro de la misma union printf("Coloca un valor en el miembro flotante e imprime ambos miembros\n"); printf("int:%d double:%f\n",valor.x,valor.y ); } Salida:


25

EJERCICIOS PROPUESTOS:

1. El profesor de la asignatura de Programación Estructurada desea conocer el porcentaje de:

� Alumnos de Sexo Femenino y Masculino. � Aprobados y reprobados, tomando en cuenta que la nota mínima para aprobar es 60 pts. La información de los estudiantes está almacenada en una variable de tipo struct llamada “estudiante”. Realizar un programa en C que permita crear un array de estructuras con los datos de los N estudiantes.

2. Realizar un programa en C de Facturación de Clientes. Los clientes tienen un nombre, número de unidades solicitadas, precio de cada unidad y el estado en que se encuentra: moroso, atrasado, solvente. Dicho programa deberá mostrar los siguientes listados:

� Clientes en estado moroso, solvente, atrasado. � Clientes en estado atrasado con facturas mayores de una determinada cantidad.

3. Se desea informatizar los resultados obtenidos por los equipos de baloncesto y de fútbol de León. La información de cada equipo:

� Nombre del equipo. � Número de Victorias. � Número de Derrotas. Para los equipos de baloncesto añadir la siguiente información: � Número de perdidas de balón. � Número de rebotes alcanzados. � Nombre del mejor anotador de triples. Para los equipos de fútbol añadir la información: � Número de empates. � Número de goles a favor. � Número de goles en contra. � Nombre del goleador del equipo.

Dicho programa deberá mostrar los siguientes listados: � Mejores triplistas de cada equipo de baloncesto. � Goleadores de cada equipo de fútbol. � Nombre del equipo de baloncesto con menor número de victorias de balón. � Nombre del equipo de fútbol con mayor número de derrotas.


26

� BIBLIOGRAFÍA BÁSICA: ♦ Ceballos, Francisco Javier: C/C++ Curso de Programación, 2da Edición. Editorial RA-MA,

2002.

♦ Joyanes Aguilar, Luis; Zahonero Martínez Ignacio: Programación en C. McGraw Hill, 2001. ♦ Gottfried, Byron S: Programación en C. McGraw Hill, 1991.

declaraciÓn de tipos propios (estructuras y uniones… · declaraciÓn de tipos propios...

Documents