C++ cap8

Tema 8 - Estructuras, campos de bit, uniones y
enumeraciones.
8.1 - Estructuras.
Una estructura es un conjunto de variables que se referencian bajo el mismo
nombre. La sintaxis de la declaración de una estructura en lenguaje C es:
struct nombre_estructura{
   tipo nombre_variable;
   tipo nombre_variable;
   ...
   tipo nombre_variable;
}variables_estructura;
Es posible no poner el nombre de la estructura (nombre_estructura), o bien, no
crear  en  el  momento  de  declarar  la  estructura  ninguna  variable  de  la  estructura
(variables_estructura),  pero no es posible eliminar la aparición de ambos elementos.
Veamos algunos ejemplos de declaración de estructuras:
struct LISTA{
   int tam;
char cadena[50];
}var_lista;
struct DATO{
int tam;
float vector[3];
struct DATO *siguiente;
};
struct {
float a,b;
unsigned long i,j;
char cadena[5];
}memo[10];
struct ALFA{
int a;
float b;
};
struct BETA{
struct ALFA alfa;
float c,d;
}variable;
Para referenciar un elemento de una estructura se realiza de la siguiente forma:
variables_estructura.nombre_variable;El lenguaje de programación C
Así,  podíamos  referenciar  los  elementos  de  las  estructuras  anteriores  de  la
siguiente forma:
var_lista.tam;
var_list.cadena;
var_list.cadena[7];
memo[2].a;
memo[6].cadena[3];
variable.alfa.a;
variable.c;
Un aspecto que es necesario aclarar es el paso de estructuras como parámetros
a las funciones. A una función es posible pasarle un elemento de los que componen la
estructura, una estructura entera, e incluso, un array de estructuras. En caso de pasarle
un elemento de la estructura, el paso se hace siguiendo las reglas del tipo del cual sea
ese elemento; en el caso de una estructura entera, C la pasa, a no ser que se le indique
o contrario, por valor,  y en el caso de un array de estructuras,  como todo array,  lo
pasara por "referencia". Conviene aclarar  en este momento que si la estructura posee
en su interior un array de elementos,  la estructura puede ser pasada por valor a una
función, pero el array será pasado siempre por referencia. En concreto a la función se
e pasara por valor un puntero al primer elemento del array.  Veamos todo esto en un
ejemplo:
struct ALFA{
   int a;
char b[20];
};
void PasoDeElementos(int val,char *cadena)
{
   val=15;
   cadena[7]=‘a’;
}
void PasoDeLaEstructuraPorValor(struct ALFA a)
{
   a.val=14;
   a.cadena[6]=‘b’;
}
void PasoDeLaEstructuraPorReferencia(struct ALFA *a)
{
   *(a.val)=13;
   *(a.cadena)[5]=‘c’;
}
void PasoDeUnArrayDeEstructuras(struct ALFA *a)
{
   a[4].val=12;
   a[5].cadena[4]=‘d’;
}
int main(void)
{
   struct ALFA a,b[10];El lenguaje de programación C
   PasoDeElementos(a.val,a.b);
   PasoDeLaEstructuraPorValor(a);
   PasoDeLaEstructuraPorReferencia(&a);
   PasoDeUnArrayDeEstructuras(b);
   return 0;
}
En el  paso  de  una  estructura  por  referencia,  se  ha  usado  una  construcción
*(variable_estructura.nombre_variable), esta construcción asigna el valor que se desea
a esa variable de la estructura, pues variable_estructura.nombre_variable es un puntero
a la variable.  El  uso de los paréntesis  es necesario,  pues el  operador  . tiene menor
prioridad que el operador *. Es por ello que C introduce un nuevo operador, el operador
->. Este operador es equivalente al otro, pero más cómodo y fácil de escribir y de usar.
Entonces, podríamos haber escrito la función de paso de una estructura por referencia
de la forma siguiente:
void PasoDeLaEstructuraPorReferencia(struct ALFA *a)
{
   a->val=13;
   a->cadena[5]=‘c’;
}
8.2 - Campos de bit.
Un campo de bit es un método predefinido por C para poder acceder a un bit de
un byte. Aunque dicho acceso siempre es posible mediante operaciones el uso de los
operadores  sobre  bits,  explicados  con anterioridad,  el  uso de  campos  de  bit  puede
añadir claridad al programa.
El método de declaración de un campo de bit se basa en la estructura, pues un
campo de bit no es mas que un tipo especial de estructura. El formato de declaración
de un campo de bit es:
struct nombre_campo_bit{
   tipo nombre1 : longitud;
   tipo nombre2 : longitud;
   ...
   tipo nombreN : longitud;
}variables_campo_bit;
El  tipo de un campo de bit  debe declararse  como  unsigned int o  signed int.
Veamos un ejemplo de declaración de un campo de bit:
struct ALFA{
   unsigned a : 1;
signed b : 2;
unsigned : 4;
unsigned c : 1;
}campo;
En dicho ejemplo, se declara un campo de bit de tamaño 4 al cual no se le da
nombre, eso es valido, y su efecto es que esos cuatro bits no podrían ser referenciados.El lenguaje de programación C
Es  posible  mezclar  en la  declaración elementos  normales  de  estructura  con
elementos de campo de bit. Veamos un ejemplo:
struct EMP{
   char nombre[20],apellido[2][20];
   float sueldo;
   unsigned vacaciones:1;
   unsigned enfermo:1;
};
8.3 - Uniones.
En C una unión es una posición de memoria que se usa por varias variables
similares, que pueden ser de tipos diferentes. La definición de unión es:
union nombre_union{
   tipo nombre1;
   tipo nombre2;
...
   tipo nombreN;
}var_union;
Como puede observarse su declaración, etc., es parecida a la declaración de una
estructura.  Sin embargo, en una unión, todos los tipos de datos comparten la misma
dirección de memoria. Así, si declaramos:
union ALFA{
   int a;
char b;
}alfa;
Tendremos:
<------alfa.a------>
Byte0    Byte1
<-alfa.b->
Por lo tanto, b tendrá en común con a el byte más bajo.
Un ejemplo mas útil de una unión es el siguiente:
union BETA{
unsigned short a;
char b[2];
};beta
Entonces  beta.b[0] contendrá el byte bajo de  beta.a, y  beta.b[1] contendrá el
byte alto de beta.a. Ello permite acceder a la parte alta o baja de dicho unsigned short
sin necesidad de usar operadores sobre bits.El lenguaje de programación C
8.4 - Enumeraciones.
Una enumeración es un conjunto de constantes enteras con nombre y especifica
todos  los  valores  legales  que  pueden  tener  unas  variables.  Las  enumeraciones  se
declaran de la siguiente forma:
enum nombre_enum{lista_de_enumeración} lista_de_variables;
Donde,  al  igual  que  en las  estructuras,  puede  no aparecer  nombre_enum o
ista_de_variables. Veamos un ejemplo de enumeración:
enum MONEDAS{ peseta, duro, diez, cinco, cincuenta, cien, doscientas,
quinientas} monedas_espana;
Las enumeraciones asignan una constante entera a cada uno de los símbolos de
a enumeración,  empezando por  el  valor  0.  Esto puede modificarse colocando en la
declaración el valor que deseamos tengan los elementos a partir de uno dado. Esto se
realiza de la siguiente forma:
enum CURSO{ primero, segundo, tercero, cuarto_t=100, quinto_t,
cuarto_e=200, quinto_e};
En este caso, las constantes primero, segundo y tercero tienen los valores 0,1 y
2, las constantes cuarto_t y quinto_t los valores 100 y 101, y las constantes cuarto_e y
quinto_e los valores 200 y 201 respectivamente.
8.5 - La palabra reservada typedef.
El lenguaje C permite mediante el uso de la palabra reservada  typedef definir
nuevos nombres para los tipos de datos  existentes,  esto no debe confundirse con la
creación de un nuevo tipo de datos. La palabra clave typedef permite solo asignarle un
nuevo nombre a un tipo de datos ya existente. La sintaxis general de uso de typedef es:
typedef tipo nombre;
Donde tipo es cualquier tipo de datos permitido, y nombre es el nuevo nombre
que se desea tenga ese tipo. Veamos algunos ejemplos:
typedef int entero;
typedef struct{
   unsigned codigo;
char nombre[40];
   char apellido[40];
}cliente;
Y entonces podrían crearse nuevas variables de la forma:
entero a;
cliente b,*c;