Estructuras, unidad 8

INTRODUCCIÓN

Las estructuras (struct) son agrupaciones de una o más variables de tipos posiblemente diferentes, agrupadas bajo un solo nombre, que permite un manejo más cómodo de la agrupación de la información. Las struct son estructuras de datos similares a los registros (record) de Pascal. 

Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de datos de diferente tipo. Los datos que contiene una estructura pueden ser de tipo simple (caracteres, números enteros o de coma flotante etc.) o a su vez de tipo compuesto (vectores, estructuras, listas, etc.). 

A cada uno de los datos o elementos almacenados dentro de una estructura se les denomina miembros de esa estructura y éstos pertenecerán a un tipo de dato determinado.

DEFINICIÓN DE ESTRUCTURAS

Se dispone de una forma de definir variables de esos grupos básicos, y los mecanismos de  acceso a las componentes: el discriminador del campo (un punto) para las estructuras; y los paréntesis cuadrados o corchetes para delimitar el índice de la componente del arreglo. Las operaciones que están definidas para estos grupos básicos son muy reducidas, el programador debe crear sus propias funciones o métodos para efectuar operaciones más complejas sobre estos grupos básicos. En el caso de strings existe una biblioteca estándar de funciones que los manipulan.

struct:  es una palabra reservada de C que indica que los elementos que vienen agrupados a continuación entre llaves componen una estructura.

nombre_estructura: identifica el tipo de dato que se describe y del cual se podrán declarar variables. Se especifica entre corchetes para indicar su opcionalidad.

miembro1, miembro2,...: Son los elementos que componen la estructura de datos, deben ser precedidos por el tipo_dato al cual pertenecen.

 

 Recordemos que una estructura define un tipo de dato, no una variable, lo que significa que no existe reserva de memoria cuando el compilador está analizando la estructura. Posteriormente habrá que declarar variables del tipo definido por la estructura para poder almacenar y manipular datos.
 
 La declaración de variables de un determinado tipo de estructura de datos se puede realizar de dos modos:
 Primera: Incluir en la propia definición de la estructura aquellas variables que se van a emplear en el programa. Esta declaración de variables  implica que el ámbito en el que éstas son reconocidas será el mismo que el de la declaración del tipo de dato estructura.

Ejemplo: estructura de una tarjeta bancaria, utilizando esta primera forma:
 

struct  {

long_int  num_tarjeta;

char tipo_cuenta;

char nombre [80];

float  saldo;

} cliente1, cliente2;

 
 

Segunda: Definir el tipo de dato estructura con un nombre determinado y declarar posteriormente las variables de ese tipo de dato. Para ello la estructura se identificará con un nombre de forma obligatoria. 

Ejemplo: estructura de una tarjeta bancaria, utilizando la segunda forma:
 

struct  {

long_int  num_tarjeta;

char tipo_cuenta;

char nombre [80];

float  saldo;

}

struct  tarjetas cli1, cli2;

INICIALIZACIÓN DE ESTRUCTURAS

Las estructuras, al igual que las matrices, almacenan sus miembros de forma contigua, razón por la cual, como veremos más adelante, se les pueden aplicar punteros y una cierta aritmética. Por la misma razón, se pueden crear matrices de estructuras e incluso estructuras de matrices (sus miembros son matrices). Conceptualmente, estas últimas no se diferencian gran cosa de las matrices de matrices (a no ser en la notación de acceso a sus miembros). También se puede calcular su tamaño en bytes con la expresión sizeof, aunque a este respecto debe tenerse en cuenta algunas posibles discrepancias respecto a los valores "teóricos", debidas a las alineaciones internas realizadas por el compilador

Se ha señalado que, al igual que las matrices, las estructuras pueden iniciarse, incluso en el mismo punto de su declaración, con una lista de iniciadores entre corchetes { } separados por comas [1], uno para cada miembro de la estructura. Por ejemplo, la sentencia:

struct Cliente {int i; char str[20]; double d;} s = {33, "Pepe Lopez", 3.14 };

declara una estructura Cliente compuesta por un entero; un array de 20 caracteres, y un doble.También inicia una estructura s como perteneciente al tipo Cliente con valores concretos en cada campo.

En estructuras o uniones con duración automática, el iniciador debe ser alguno de los siguientes:

·         Una lista de inicializadores constantes (también se permiten expresiones con sizeof) Ejemplo:

struct punto {int x; int y;} p1 = {1, 2};

·         Una sola expresión con una estructura de tipo compatible.  En este caso, el valor inicial del objeto es el de la expresión.  Ejemplo:

struct punto p2 = p1;

En este caso, (suponiendo los valores anteriores) sería: p2.x == 1 y p2.y == 2

Los miembros complejos de listas de iniciadores. Por ejemplo matrices, pueden inicializarse con expresiones adecuadas incluidas en bloques de corchetes anidados. Por ejemplo:

struct Pesadas {

   int tiket;

   int pesos[5];

} s = { 150, {10, 45, 0, 78, 20}};

Si la lista de inicializadores contenidos entre los corchetes { } es menor que los miembros de la estructura, el resto de los miembros es inicializado implícitamente siguiendo las mismas reglas que los objetos con duración estática.

UTILIZACIÓN DE ESTRUCTURAS CON FUNCIONES

Es posible pasar estructuras a las funciones como argumentos. En el siguiente ejemplo usaremos funciones, para ello escribiremos dos nuevas funciones, una de ellas leerá del teclado la información sobre un nuevo trabajador y la otra visualizará en pantalla la información de un trabajador.

#include<stedio.h>

#define LONGITUD 30

Struct trabajadores

{

    Char nombre [LONGITUD];

    Int num:

};

/****

La función nuevo_nombre lee la información de un nuevo trabajador y la función visualizar_datos visualiza la información de un trabajador

****/

Struct trabajadores nuevos_nombre(void) ;

Void visualizar_datos (struct trabajadores currela) ;

Void main(void main)

{

             Struct trabajadores tra_1;

             Struct trabajadores tra_2;

           Tra_1 = nuevo_nombre()

           Tra_2 = nuevo_nombre()

          Printf(“LISTA DE AGENTES SECRETOS :\n");”

          Visualizar_datos (tra_1);

          Visualizar_datos (tra_1);

}

/*

Como se puede apreciar esta función devuelve una estructura tipo trabajadores donde se almacena la información necesaria sobre cada trabajador, utilizando para ella la sentencia return.

*/

Struct trabajadores nuevo_nombre(void)

{

       Struct trabajadores currela;

       printf("\nDatos del agente.\introduce el nombre:");

       gets(currela.nombre) ;

      printf (“introduce el numero:");

     scantf (“%d”,& currela.num);

     fflush (stdin);

     return (currela);

}

Void visualizar_datos (struct trabajadores currela)

{

     Printf (“\n\n Agente secreto \n”);

     Printf (“\t nombre : %s \n” currela.nombre);

     Printf (“\t numero del agente %d\n”,currela.num);

}

CONCLUSIÓN

Cuando compilamos este programa el compilador puede dar un mensaje diciendo que la función visualizar_datos toma la estructura como valor y no como dirección, de seguro mucho de nosotros tenemos en mente la solución medante la utilización de punteros