INSTITUTO POLITÉCNICO NACIONAL.

Escuela Superior de Ingeniería Mecánica y Eléctrica.

“Unidad Zacatenco"

Ingeniería en Comunicaciones y Electrónica

ESTRUCTURA Y BASE DE DATOS

PROYECTO FINAL:
“ESTRUCTURA Y UNION”
TRABAJO: “DESARROLLO TEORICO”

ALUMNO:

CRUZ DELGADILLO DANIEL

ROJAS MAVILLARD JOSUÈ BERNARDO

MALAGON SANCHEZ MIGUEL ANGEL

PROFESOR:

CORTES HERNANDEZ LILIA

GRUPO: 3CV4 TURNO: Vespertino

ESTRUCTURA

Una estructura (struct) permite agrupar variables de varios tipos bajo un mismo
nombre. De esta forma es posible crear elementos de datos complejos, basándose en
los tipos básicos que suministra el lenguaje de programación.

Una declaración de estructura define un tipo, y por lo tanto será posible definir
variables de este nuevo tipo. Cada una de estas variables estará compuesto a su vez
por las variables que se definieron en la estructura.

Una declaración típica de estructuras sería:

struct nombre {

componente1 ;

componente2 ;

...

componenteN ;

} lista-variables ;

Cada uno de los componentes de la estructura tiene a su vez la forma de una

declaración de variables:

tipo nombre ;

Por ejemplo, para declarar una estructura que permita manejar, de manera conjunta,
los datos de algunos alumnos de determinado curso, se podría hacer:

struct Alumno {

char Nombre[30];

char NumAlumno[8];

float Nota1;

float Nota2;

float Nota3;

float NotaFinal;

} A1, A2, A3;

Esta declaración define tres variables (A1, A2 y A3), cada una compuesta a su vez por
un string para el nombre, un string para su número de alumno, tres float para sus notas
parciales, y un float para su nota final.

Los elementos que componen una estructura se acceden mediante la notación:

estructura.componente
Por ejemplo, el string que contiene el nombre del segundo alumno se referencia como:

A2.Nombre

Al igual que con los tipos simples de C, es posible definir vectores compuestos de
estructuras. Así, sería posible hacer la definición anterior aplicable a un mayor número
de alumnos:

struct Alumno {

char nombre[30];

char NumAlumno[8];

float Nota1;

float Nota2;

float Nota3;

float NotaFinal;

} Alumnos[NUM_ALUMNOS];

En este caso, el nombre del primer alumno se referenciaría como:

Alumnos[0].Nombre

En las versiones ANSI de C (como gcc), también es posible asignar estructuras, pasarlas
como argumentos a funciones y retornarlas como resultado de funciones. En el caso
del paso de estructuras como argumento, éstas se pasan por referencia, por lo que es
posible cambiar el contenido de las variables dentro de la función y los cambios se
propagarán al retornar. Las siguientes acciones y declaraciones serían válidas:

A2 = A1; /* Asignacion de una estructura a otra */

/* Funcion que retorna una estructura */

struct Alumno NuevoAlumno(char Nombre[]) { ...

/* Funcion que recibe como argumento una estructura */

void CalculaNota(struct Alumno A1) { ...

Importante:

Observe que el nombre del tipo que debe usarse lleva incluido el prefijo struct. Para el
caso de nuestro ejemplo:

struct Alumno

Haciendo uso de typedef será posible manejar estos nuevos tipos sin necesidad de
acarrear constantemente el prefijo mencionado.
Una vez dada la declaración inicial de una estructura, es posible definir más variables
del nuevo tipo definido. Esto se hace siguiendo la sintaxis:

struct nombre var1, var2, ... ;

Continuando con el ejemplo inicial, podrían definirse estructuras adicionales para

almacenar la información de otros alumnos:

struct Alumno A4, A5;

También es posible inicializar estructuras durante su declaración, empleando una

sintaxis similar a la utilizada para inicializar vectores. Por ejemplo:

struct Alumno A = {"Elvira", "98231465", 6.0, 5.5, 5.0, 5.5};

Struct (lenguaje de programación C)

UNION

Sinopsis

Las uniones C++ son un tipo especial de clase; un tipo de variable con cierta similitud
con las estructuras. Pueden albergar diferentes tipos de datos, pero solo uno, de entre
todos los posibles, al mismo tiempo. Se dice que solo uno puede estar "activo" en cada
momento, y se corresponden con los registros de tipo variable de Pascal y Modula-2.
Como el lector estará suponiendo, el tamaño de una unión es el del mayor elemento
que puede albergar. El valor exacto depende de la implementación y de las
alineaciones internas.

Como se verá a continuación, desde el punto de vista de su organización interna son

como estructuras en las que todos sus miembros tuviesen el mismo desplazamiento
respecto al origen. Desde un punto de vista funcional pueden ser considerados
almacenamientos u objetos multi-uso.

En realidad las uniones son un recurso de programación que permite alojar distintos
tipos de objetos en un mismo espacio cuando estos objetos no coexisten en el tiempo
y no hay suficiente memoria disponible para asignarles espacios distintos. Se trata por
tanto de objetos muy especializados en cuanto a su uso, propio de aplicaciones muy
"afinadas", de tiempos en que la memoria era un bien escaso, pero cuya utilización
real es bastante rara y desaconsejada.

2 Declaración

La sintaxis de declaración es similar a las estructuras con las siguientes diferencias:

a: Las uniones pueden contener campos de bits ,pero solo uno puede estar activo.
Todos comienzan en el principio de la unión y como consecuencia, dado que los
campos de bits son dependientes de la implementación, pueden presentar problemas
para escribir código portable.

b: Un objeto que tenga constructor o destructor no puede ser utilizado como miembro
de una unión.
c: A diferencia de las estructuras, en las uniones C++ no se permiten los
especificadores de acceso public, private y protected de las clases. Todos sus campos
son públicos.

d: Las uniones solo pueden ser inicializadas en su declaración mediante su primer

miembro. Ejemplo:

union local87 {

int i;

double d;

} a = { 20 };

2.1 Ejemplo

union miUnion { // definición de unión de nombre miUnion

int i;

double d;

char ch;

char *ptr;

} mu, *muptr=μ // declara un objeto y un puntero al objeto

Aquí se ha definido un tipo nuevo de la clase unión, identificado como miUnion; se ha

instanciado un objeto de dicha clase, denominado mu, que puede utilizarse para
almacenar un int, (4 bytes), un double (8 bytes), o un char (1 byte), pero solo uno cada
vez.

El uso debe ser consistente con los valores almacenados en cada caso, cuestión esta
que queda bajo responsabilidad del programador (esta es la razón principal para que
se desaconseje su uso salvo caso de necesidad insoslayable). Si se lee un dato de tipo
distinto al que se escribió, el resultado obtenido es dependiente de la implementación.

Una unión no puede participar en la jerarquía de clases; no puede ser derivada de

ninguna clase, ni ser una clase base. Aunque sí pueden tener un constructor y ser
miembros de clases.

3 Acceso a miembros

Como en el caso de las estructuras, se dispone de dos operadores para referenciar los
miembros de las uniones:

. Selector directo

Una expresión del tipo Un.obj representa el objeto obj de la unión Un. La expresión es
un Lvalue siempre que Un no lo sea y obj no sea una matriz.

-> Selector indirecto

Una expresión del tipo uPtr -> obj representa el objeto obj de la unión Un siempre que
uPtr sea un puntero a dicha unión. La expresión es un Lvalue siempre que obj no sea
una matriz. Esta expresión es equivalente, y preferible, a (*uPtr).obj.

El uso de uno u otro selector es indiferente. Depende de que se tenga un identificador

de la unión, en cuyo caso puede usarse el selector directo (expresión Un.obj), o un
puntero, en cuyo caso puede usarse el indirecto (expresión uPtr->obj). En cualquier
caso, es necesaria cierta atención como se muestra en el ejemplo (referido al objeto
mu declarado anteriormente):

mu.d = 4.016; // Se inicia mu

printf("mu.d = %f\n",mu.d); //Ok. Salida: mu.d = 4.016

printf("mu.i = %d\n",mu.i); //?? resultado particular

mu.ch = 'A';

printf("mu.ch = %c\n",mu.ch); //Ok. Salida: mu.ch = A

printf("mu.d = %f\n",mu.d); //?? resultado particular

muptr->i = 3;

printf("mu.i = %d\n",mu.i); //Ok. Salida: mu.i = 3

El segundo printf es legal, dado que mu.i es un entero. El problema es que el patrón de
bits que correspondería a mu.i coincide con parte del double previamente asignado
en la primera sentencia, y su valor no tiene ningún sentido considerado aisladamente.

Como se ha señalado, las uniones comparten muchas características con las

estructuras, incluyendo la notación. Además, con las uniones están permitidas las
mismas operaciones que con las estructuras: asignación o copia como una unidad;
obtener su dirección, y acceder a un miembro.

4 Punteros a uniones

Cuando son modelados adecuadamente, los punteros a una unión señalan a cada
uno de sus miembros y viceversa.

5 Tamaño y alineación

Como en el resto de los objetos, su tamaño puede ser establecido en tiempo de

ejecución con el operador sizeof y como se ha señalado, corresponde con el mayor
de los elementos que pueda almacenar. Lo mismo que en las estructuras, también
aquí se producen alineaciones en las direcciones de memoria de los miembros.

Por ejemplo, si nos referimos a la unión anterior, las sentencias sizeof(union miUnion) y
sizeof(mu), ambas devuelven 8; este es el tamaño en bytes de la unión, que
corresponde a la opción más desfavorable, cuando se almacena un double, pero
cuando mu almacena un int existen 4 bytes desaprovechados, y 7 cuando se
almacena un char.

6 Uniones anónimas
Uniones anónimas son aquellas que no tienen etiqueta y tampoco se utilizan para
declarar un objeto nominado (con nombre). Tienen la forma general:

union { lista-de-miembros };

Sus miembros pueden ser accedidos directamente en el ámbito de su declaración sin

necesidad de usar ninguno de los operadores de acceso x.y o p->y. Ejemplo:

#include <iostream.h>

void main () {

union { int i; double d; };

i = 25;

cout << "El valor de '?.i' es: " << i << endl;

Salida:

El valor de '?.i' es: 25

6.1 Las uniones anónimas pueden ser globales, y anidadas o sin anidar.

Ejemplo:

#include <iostream.h

static union { int i; double d; } ;

void main () {

i = 15;

cout << "El valor de '?.i' es: " << i << endl;

union { int i; double d; };

i = 25;

cout << "El valor de '?.i' es: " << i << endl;

cout << "El valor de '?.i' es: " << ::i << endl;

Salida:

El valor de '?.i' es: 15

El valor de '?.i' es: 25

El valor de '?.i' es: 15

6.2 Las uniones anónimas no pueden tener funciones miembro ni miembros privados o
protegidos (todos son públicos). Si son globales deben ser declaradas estáticas, y sin
son locales pueden ser estáticas o automáticas. En otras palabras: las uniones
anónimas no pueden tener enlazado externo.

Ejemplo:

#include <iostream.h>

union { int i; double d; } ;

void main () {

cout << "El valor '?.i' es: " << i << endl;

Resulado de la compilación:

Borland C++: Error E2020 pru1.c 2: Global anonymous union not static

Compilador GNU C++ 3.3.1 namespace-scope anonymous aggregates must be static

7 Uniones anónimas anidadas

La estructura, clase o unión exterior de una unión anónima anidada debe tener un
nombre. C++ permite uniones anónimas anidadas. Por ejemplo:

struct externa { // define estructura nominada externa

int x;

union { // unión anónima anidada

int y;

char c;

};

};

...

int main(void) {

struct externa ex1; // ex1 es una instancia de externa

return ex1.x + ex1.y;

8 Uniones y otros tipos

Las uniones pueden aparecer en matrices, estructuras y como miembros de clases. A

su vez, también pueden contener a dichos elementos.