Estructuras y Uniones en C - Arrays de estructuras

Una estructura es una colección de elementos finita y heterogénea. Se utilizan para resolver problemas que involucran tipos de datos estructurados.

Estructuras y Uniones en C - Arrays de estructuras | Aprender Programación en C | Una estructura es una colección de elementos finita y heterogénea. Se utilizan para resolver problemas que involucran tipos de datos estructurados
COMPÁRTELO:

Concepto de estructura

Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo.

Su utilización más habitual es para la programación de bases de datos, ya que están especialmente indicadas para el trabajo con registros o fichas.

La sintaxis de su declaración es la siguiente:

struct tipo_estructura
{
tipo_variable nombre_variable1;
tipo_variable nombre_variable2;
tipo_variable nombre_variable3;
};

Donde tipo_estructura es el nombre del nuevo tipo de dato que hemos creado. Por último, tipo_variable y nombre_variable son las variables que forman parte de la estructura.

Para definir variables del tipo que acabamos de crear lo podemos hacer de varias maneras, aunque las dos más utilizadas son éstas:

Una forma de definir la estructura:


	struct trabajador
	{
		char nombre[20];
		char apellidos[40];
		int edad;
		char puesto[10];
	};
	struct trabajador fijo, temporal;

Otra forma


	struct trabajador
	{
		char nombre[20];
		char apellidos[40];
		int edad;
		char puesto[10];
	}fijo, temporal;

En el primer caso declaramos la estructura, y en el momento en que necesitamos las variables, las declaramos. En el segundo las declaramos al mismo tiempo que la estructura. El problema del segundo método es que no podremos declarar más variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo estructura, la estructura tiene que estar declarada previamente. Se debe declarar antes de la función main.

El manejo de las estructuras es muy sencillo, así como el acceso a los campos ( o variables ) de estas estructuras. La forma de acceder a estos campos es la siguiente:

variable.campo;

Donde variable es el nombre de la variable de tipo estructura que hemos creado, y campo es el nombre de la variable que forma parte de la estructura.

temporal.edad=25;

Lo que estamos haciendo es almacenar el valor 25 en el campo edad de la variable temporal de tipo trabajador.

Otra característica interesante de las estructuras es que permiten pasar el contenido de una estructura a otra, siempre que sean del mismo tipo naturalmente:

fijo=temporal;

Al igual que con los otros tipos de datos, también es posible inicializar variables de tipo estructura en el momento de su declaración:

struct trabajador fijo={"Pedro","Hernández Suárez", 32, "gerente"};

Si uno de los campos de la estructura es un array de números, los valores de la inicialización deberán ir entre llaves:


	struct notas
	{
		char nombre[30];
		int notas[5];
	};
	struct notas alumno={"Carlos Pérez",{8,7,9,6,10}};

Estructuras y funciones

Podemos enviar una estructura a una función de las dos maneras conocidas:

  1. Por valor: su declaración sería:
    • void visualizar(struct trabajador);

Después declararíamos la variable fijo y su llamada sería:

visualizar(fijo);

Por último, el desarrollo de la función sería:

void visualizar(struct trabajador datos)

Ejemplo


	/* Paso de una estructura por valor. */

	#include <stdio.h>

	struct trabajador
	{
		char nombre[20];
		char apellidos[40];
		int edad;
		char puesto[10];
	};

	void visualizar(struct trabajador);
	main() /* Rellenar y visualizar */
	{
		struct trabajador fijo;
		printf("Nombre: ");
		scanf("%s",fijo.nombre);
		printf("\nApellidos: ");
		scanf("%s",fijo.apellidos);
		printf("\nEdad: ");
		scanf("%d",&fijo.edad);
		printf("\nPuesto: ");
		scanf("%s",fijo.puesto);
		visualizar(fijo);
	}

	void visualizar(struct trabajador datos)
	{
		printf("Nombre: %s",datos.nombre);
		printf("\nApellidos: %s",datos.apellidos);
		printf("\nEdad: %d",datos.edad);
		printf("\nPuesto: %s",datos.puesto);
	}

  1. Por referencia: su declaración sería:
    • void visualizar(struct trabajador *);

Después declararemos la variable fijo y su llamada será

visualizar(&fijo);

Por último, el desarrollo de la función será:

void visualizar(struct trabajador *datos)

Fíjate que en la función visualizar, el acceso a los campos de la variable datos se realiza mediante el operador ->, ya que tratamos con un puntero. En estos casos siempre utilizaremos el operador ->. Se consigue con el signo menos seguido de mayor que.

Ejemplo


	/* Paso de una estructura por referencia. */

	#include <stdio.h>

	struct trabajador
	{
		char nombre[20];
		char apellidos[40];
		int edad;
		char puesto[10];
	};

	void visualizar(struct trabajador *);
	main() /* Rellenar y visualizar */
	{
		struct trabajador fijo;
		printf("Nombre: ");
		scanf("%s",fijo.nombre);
		printf("\nApellidos: ");
		scanf("%s",fijo.apellidos);
		printf("\nEdad: ");
		scanf("%d",&fijo.edad);
		printf("\nPuesto: ");
		scanf("%s",fijo.puesto);
		visualizar(&fijo);
	}

	void visualizar(struct trabajador *datos)
	{
		printf("Nombre: %s",datos->nombre);
		printf("\nApellidos: %s",datos->apellidos);
		printf("\nEdad: %d",datos->edad);
		printf("\nPuesto: %s",datos->puesto);
	}

Arrays de estructuras

Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras:

Ejemplo


	struct trabajador
	{
		char nombre[20];
		char apellidos[40];
		int edad;
	};

	struct trabajador fijo[20];

Así podremos almacenar los datos de 20 trabajadores. Ejemplos sobre como acceder a los campos y sus elementos: para ver el nombre del cuarto trabajador, fijo[3].nombre;. Para ver la tercera letra del nombre del cuarto trabajador, fijo[3].nombre[2];. Para inicializar la variable en el momento de declararla lo haremos de esta manera:

struct trabajador fijo[20]={{"José","Herrero Martínez",29},{"Luis","García Sánchez",46}};

Typedef

Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras: El lenguaje 'C' dispone de una declaración llamada typedef que permite la creación de nuevos tipos de datos. Ejemplos:

typedef int entero; /* acabamos de crear un tipo de dato llamado entero */
entero a, b=3; /* declaramos dos variables de este tipo */

Su empleo con estructuras está especialmente indicado. Se puede hacer de varias formas:

Una forma de hacerlo:


	struct trabajador
	{
		char nombre[20];
		char apellidos[40];
		int edad;

	};

	typedef struct trabajador datos;
	datos fijo,temporal;

Otra forma:


	typedef struct
	{
		char nombre[20];
		char apellidos[40];
		int edad;
	}datos;

	datos fijo,temporal;

CITAR ARTÍCULO


Para tareas, investigaciones, tesis, libros, revistas, blogs ó artículos académicos

Referencia en Formato APA:

Delgado, Hugo. (2020).
Estructuras y Uniones en C - Arrays de estructuras.
Recuperado 24 de mayo, 2020, de
https://disenowebakus.net/estructuras.php

¡Participa!

¡Compártelo con tus amigos en Redes Sociales!
Compartir en:

Profesor en la Universidad de Guadalajara

Hugo Delgado Desarrollador y Diseñador Web en Puerto Vallarta

Profesional en Desarrollo Web y Posicionamiento SEO desde hace más de 15 años continuos.
Contamos con más de 200 constancias y reconocimientos en la trayectoria Académica y Profesional, incluidos diplomados certificados por Google.

CONTINÚA APRENDIENDO

TAMBIÉN MERECE LA PENA VISITAR:

¿Todavía no encuentras lo que necesitas?

Usa nuestro buscador interno para descubrir más información
Contenido patrocinado:

¿Te gustaría aprender más sobre Diseño Web?

Conoce todos los cursos y tutoriales que tenemos para ti completamente gratis
Aprender Diseño Web
 

Deja tu Comentario