Unidad VI Registros (estructuras, uniones y enumeraciones)

Presentación del tema: "Unidad VI Registros (estructuras, uniones y enumeraciones)"— Transcripción de la presentación:

1 Unidad VI Registros (estructuras, uniones y enumeraciones)
Computación II Unidad VI Registros (estructuras, uniones y enumeraciones)

2 Presentación de la unidad:
Objetivos: Ser capaces de crear y utilizar estructuras, uniones y enumeraciones. Ser capaces de pasar estructuras a funciones en llamadas por valor y en llamadas por referencia. Ser capaces de crear campos de bits para almacenar datos en forma compacta.

3 Presentación de la unidad:
Contenidos: Definición de estructuras. Cómo inicializar estructuras. Cómo tener acceso a los miembros de una estructura. Estructuras anidadas. Como utilizar estructuras con funciones. Typedef. Uniones Constantes de enumeración. Campos de bits.

4 Definición de estructuras
Las estructuras son colecciones de variables relacionadas bajo un mismo nombre. Son tipo de datos derivados; están construidos utilizando objetos de otros tipos. Sintaxis: struct <nombre>{ <miembros de la estructura>; }; <nombre>:identificador valido. El rotulo de la estructura esta formado por el nombre y la palabra reservada struct. <miembros de la estructura>: declaración de variables. Los miembros de la estructura pueden ser de los tipos de datos básicos o agregados, como lo son arreglos u otras estructuras.

5 Definición de estructuras
C++ permite incluir funciones en el interior de las estructuras. Normalmente estas funciones tienen la misión de manipular los datos incluidos en la estructura. La estructura no reserva ningún espacio en memoria; genera un nuevo tipo de datos que se utiliza para declarar variables. Ejemplo: struct alumno { char *nombre; char *clave; }; int main(){ struct alumno aCompu, aUniversidad[1000], *aPtr; …………… return 0; }

6 Definición de estructuras
El nombre del rotulo de la estructura es opcional; si la estructura no contiene el nombre del rotulo, las variables de este tipo de estructura pueden ser únicamente declaradas dentro de la definición de la estructura. Ejemplo: struct { char *nombre; char *clave; char *leerNombre(){return nombre;} } aCompu, aUniversidad[1000], *aPtr; Las estructuras no pueden compararse entre si, porque los miembros de una estructura no están necesariamente almacenados en bytes consecutivos de memoria.

7 Cómo inicializar estructuras
Las estructuras pueden ser inicializadas mediante listas de inicialización como los arreglos, asignándoles una variable de estructura del mismo tipo ó asignándoles valores a los miembros individuales. struct aCompu = {“Carolina”, “ ”}; aCompu.nombre=“Carolina”; aCompu.nombre = aUniversidad[100].nombre; Si en la lista aparecen menos inicializadores que en la estructura, los miembros restantes son inicializados a 0 o a Null.

8 Cómo tener acceso a miembros de estructuras
Operador de miembro de estructura (.), también conocido como operador punto. Operador apuntador de estructura (->), también conocido como operador flecha. El operador miembro de estructura tiene acceso a un miembro de la estructura mediante el nombre de la variable de la estructura: cout<< aCompu.nombre; El operador apuntador de estructura tiene acceso a un miembro de la estructura vía un puntero a la estructura: cout<< alu->nombre; cout<< (*alu).nombre;

9 Estructuras Anidadas Los miembros de una estructura pueden ser otras estructuras. Ejemplo: struct universidad{ struct alumno alu; struct profesor{ char *nombre; char *carrera; }pro; int cantidadFacultades; }; /*Inicialización*/ struct universidad stUni ={{“Caro”, “ ”},{“Pepe”, “Ing”}, 6};

10 Estructuras Anidadas Para declarar una variable del tipo profesor hay que utilizar el operador de acceso: (::) struct universidad :: profesor uProfe; uProfe = {“Pepe”, “Ing”}; Para acceder a los miembros de las estructuras anidadas tenemos: struct universidad uni; uni.alu.nombre = “Carolina”; uni.pro.carrera = “Ingeniería”;

11 Cómo utilizar estructuras con funciones
Las estructuras pueden ser pasadas a funciones pasando miembros de la estructura individuales, pasando toda la estructura o pasando un puntero a la estructura. Cuando se pasan estructuras o miembros individuales a una función se pasan en llamadas por valor. void imprimeAlumno(struct alumno aCompu); void imprimeNombre(char *aCompu.nombre); Para pasar una estructura en llamada por referencia, se pasa la dirección de la variable estructura. void cargaDatos(struct alumno *alu);

12 Typedef Proporciona un mecanismo para la creación de sinónimos para tipos de datos anteriormente definidos. Ejemplo: struct alumno{ char *nombre; char *clave; }; typedef struct alumno ALU; ALU aCompu, aUniversidad[1000], *alu; Al declarar un nuevo nombre utilizando typedef no se crea un nuevo tipo, sino que crea un nuevo nombre de tipo.

13 Uniones Una “union” es un tipo de dato derivado cuyos miembros comparten el mismo espacio de almacenamiento. Los miembros de una “union” pueden ser de distinto tipo, y únicamente un miembro de una “union” puede ser referenciado en un momento dado. Sintaxis: union <nombre>{ <declaracion de variables>; }; En una declaración, una “union” puede ser inicializada únicamente con un valor del mismo tipo que el primer miembro de la “union”. union numero{ int x; float y; union number value={10};

14 Campos de bits C++ permite especificar el número de bits en el cual se almacena un miembro unsigned de una estructura o union. Una variable de tipo unsigned queda almacenada en por lo menos 2 bytes de memoria. Los campos de bits ayudan a ahorrar almacenamiento. Sintaxis: struct <nombre> { unsigned <tipo_entero> <identificador>:<núm_de_bits>; }; Un campo de bits no puede ocupar dos variables distintas; pero es posible combinar los campos de bits con campos normales. struct mapaDeBits{ float numero; unsigned short int campo1:3; unsigned short int campo2:4;

15 Campos de bits Ejemplo: struct mystruct { unsigned flag : 1; } M;
int prueba() {   M.flag = true; //almacena 0 ó 1   if (M.flag) cout<<("- Cierto -"); }

16 Constantes de enumeración
Una enumeración es un conjunto de constantes enteras representado por identificadores. Constantes simbólicas cuyos valores pueden ser definidos automáticamente. Los valores de una enumeración se inician con 0, a menos que se definan de otra manera, y se incrementan en 1. Sintaxis: enum <identificador> {<lista_de_constantes_simbolicas>}; Ejemplo: enum meses = {ENE, FEB, MAR, JUN, JUL, AGO, SEPT, OCT, NOV, DIC}; enum meses1 = {ENE = 1, FEB, MAR, JUN, JUL, AGO, SEPT, OCT, NOV, DIC};