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.
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
