República Bolivariana De Venezuela.

Ministerio del Poder Popular Para La Educación.

Universidad Nororiental Gran Mariscal de Ayacucho.

Facultad de Ingeniería de Sistemas.

Programación I.

2do Semestre 3d2.

Struct en lenguaje C.

Profesora: Alumna:
Thays Parra. Emilmar Cuarez.
C.I: 28619685

Puerto Ordaz, 23 de abril del 2020.

 Índice

Introducción ............................................................................................................. 3

¿Que son las estructuras? ...................................................................................... 4

Declaraciones de estructura .................................................................................... 5

Inicializar estructuras ............................................................................................... 6

¿Como tener acceso a los miembros de estructuras? ............................................ 7

¿Como utilizar estructuras con funciones? ............................................................. 8

Estructuras anidadas ............................................................................................... 8

Typedef ................................................................................................................... 9

Ejemplos usando estructuras: ............................................................................... 10

Conclusión............................................................................................................. 17

Anexos .................................................................................................................. 18

Bibliografía ............................................................................................................ 19
 Introducción

Las estructuras en lenguaje C tienen su función principal en simplificar el trabajo, de

forma en que el programa no queda tan desordenado, así que ayudan a organizar
datos complicados debido a que permiten tratar como una unidad a un conjunto de
variables.

Las estructuras permiten determinar el número de componentes y pueden contener

elementos de diversos tipos de datos, por lo que sirven para crear bases de datos
u otras aplicaciones. Nuestra primera experiencia con estructuras comienza desde
el momento en que usamos en nuestros programas variables de tipos primitivos
(char, short, int, float, etc.). La manera en que se forma una estructura es utilizando
la palabra reservada struct, seguida por un campo etiqueta opcional, y luego una
lista de miembros dentro de la estructura. De acuerdo a lo anteriormente
mencionado, se puede construir programas de grandes cantidades de código y así,
facilitar su entendimiento y orden. Para finalizar hay que reconocer que no es
posible comparar dos estructuras entre sí, pero si colocar una dentro de otra.

3
¿Qué son las estructuras?
Las estructuras son colecciones de variables relacionadas bajo un nombre. Las
estructuras pueden contener variables de muchos tipos diferentes de datos a
diferencia de los arreglos que contienen únicamente elementos de un mismo tipo
de datos.

Las estructuras son tipos de datos derivados que están construidas utilizando
objetos de otros tipos. Considere la siguiente definición de estructura:

struct ejemplo {

char c;

int i;};

La palabra reservada struct indica se está definiendo una estructura. El identificador

ejemplo es el nombre de la estructura. Las variables declaradas dentro de las llaves
de la definición de estructura son los miembros de la estructura. Los miembros de
la misma estructura deben tener nombres únicos mientras que dos estructuras
diferentes pueden tener miembros con el mismo nombre. Cada definición de
estructura debe terminar con un punto y coma. La definición de struct ejemplo
contiene un miembro de tipo char y otro de tipo int. Los miembros de una estructura
pueden ser variables de los tipos de datos básicos (int, char, float, etc) o agregados
como ser arreglos y otras estructuras. Una estructura no puede contener una
instancia de sí misma.

Declaramos variables del tipo estructura del siguiente modo:

struct ejemplo e1, a [10];

Las declaraciones anteriores declaran variables e1 de tipo ejemplo y a de tipo

arreglo de ejemplo de dimensión 10. Se pueden declarar variables de tipo estructura
ejemplo colocando sus nombres a continuación de la llave de cierre de la definición
de estructura y el punto y coma, en el caso anterior:

struct ejemplo {

4
 char c;

int i;} e1, a [10];

Una operación valida entre estructuras es asignar variables de estructura a variables

de estructura del mismo tipo. Las estructuras no pueden compararse entre sí.

Declaraciones de estructura.
Una "declaración de estructura" designa un tipo y especifica una secuencia de
valores variables (denominados “miembros” o “campos” de la estructura) que
pueden tener diferentes tipos. Un identificador opcional, denominado “etiqueta”,
proporciona el nombre del tipo de estructura y se puede usar en referencias
posteriores al tipo de estructura. Una variable de este tipo de estructura contiene la
secuencia completa definida por el tipo. Las estructuras de C son similares a los
tipos denominados "registros" en otros lenguajes.

Sintaxis de las estructuras

struct [<identificador>] {

[<tipo> <nombre_objeto> [, <nombre_objeto>,]];

} [<objeto_estructura> [, <objeto_estructura>,];

El identificador de la estructura es un nombre opcional para referirse a la estructura.

Los objetos de estructura son objetos declarados del tipo de la estructura, y su
inclusión también es opcional. Sin bien, aun siendo ambos opcionales, al menos
uno de estos elementos debe existir.

En el interior de una estructura, entre las llaves, se pueden definir todos los
elementos que consideremos necesarios, del mismo modo que se declaran los
objetos.

5
Las estructuras pueden referenciarse completas, usando su nombre, como
hacemos con los objetos que ya conocemos, y también se puede acceder a los
elementos definidos en el interior de la estructura, usando el operador de selección
(.), un punto. Una vez definida una estructura, es decir, si hemos especificado un
nombre para ella, se puede usar igual que cualquier otro tipo de C. Esto significa
que se pueden declarar más objetos del tipo de estructura en cualquier parte del
programa. Para ello usaremos la forma normal de declaración de objetos, es decir:

[struct] <identificador> <objeto_estructura>

[, <objeto_estructura>...];

También una declaración de estructura se puede representar de la siguiente

forma:

Struct Identificador_ tipo_estructura

{Tipo miembro_1; /*Declaración de los miembros*/

Tipo miembro_n;

};

Inicializar estructuras.
Las estructuras pueden ser inicializadas mediante listas de inicialización como con
los arreglos. Para inicializar una estructura escriba en la declaración de la variable
a continuación del nombre de la variable un signo igual con los inicializadores entre
llaves y separados por coma, por ejemplo: ejemplo e1 = {’a’, 10};

Si en la lista aparecen menos inicializadores que en la estructura los miembros

restantes son automáticamente inicializados a 0. Las variables de estructura
también pueden ser inicializadas en enunciados de asignación asignándoles una
variable del mismo tipo o asignándole valores a los miembros individuales de la
estructura.

6
Una estructura se puede inicializar de dos formas:

• Dentro de la sección de código de su programa.

• Como parte de la definición de la estructura, especificando los valores
iniciales, entre llaves, después de la definición de variables estructura.

Podemos inicializar una variable del tipo fecha como sigue:

Struct fecha f = {4, 7, 1776, 186,” Julio”};

Vamos a crear una declaración de estructura llamada amigo:

Struct estructura_amigo {
char nombre [30];
char apellido [40];
char teléfono [10];
int edad;
};

A cada elemento de esta estructura (nombre, apellido, teléfono, edad) se le

denomina campo o miembro, y al conjunto de los datos se le denomina registro.

¿Como tener acceso a los miembros de estructuras?

Para tener acceso a miembros de estructuras utilizamos el operador punto. El
operador punto se utiliza colocando el nombre de la variable de tipo estructura
seguido de un punto y seguido del nombre del miembro de la estructura. Por
ejemplo, para imprimir el miembro c de tipo char de la estructura e1 utilizamos el
enunciado:

printf (” %c, e1.c);

Para acceder al miembro i de la estructura e1 escribimos: e1.i. En general, un

miembro de una estructura particular es referenciada por una construcción de la
forma:
7
 Nombre_de_estructura. miembro

Por ejemplo, para chequear el nombre de mes podemos utilizar:

if (strcmp (d. nombre mes, “Agosto”) ==0)

La inicialización individual es por medio del operador punto, para la estructura

completa es con caracteres llaves y los valores de los miembros separados por
coma.

¿Como utilizar estructuras con funciones?

Las estructuras pueden ser pasadas a funciones pasando miembros de estructura
individuales o pasando toda la estructura.

Cuando se pasan estructuras o miembros individuales de estructura a una función

se pasan por llamada por valor. Para pasar una estructura en llamada por referencia
tenemos que colocar el’*’ o’&’.

Los arreglos de estructura como todos los demás arreglos son automáticamente
pasados en llamadas por referencia.

Si quisiéramos pasar un arreglo en llamada por valor, podemos definir una

estructura con único miembro el array. Una función puede devolver una estructura
como valor.

Estructuras anidadas.
La conveniencia de coger nombres de funciones y datos fuera del espacio de
nombre global es aplicable a las estructuras. Puede anidar una estructura dentro de
otra estructura, y por tanto guardar juntos elementos asociados.

En ocasiones veremos que habrá cierta similitud entre muchas cosas, por ejemplo,
si quisiéramos hacer una estructura para registrar los datos de un cliente por cada
compra en un súper mercado, es normal pensar que vamos a necesitar un programa
que lea su nombre, apellido, edad, número de identificación y número de teléfono,
8
ahora, piensen en que si queremos hacer una estructura para almacenar lo datos
de una persona que se quiera inscribir en un centro educativo, pediríamos lo mismo.

Las estructuras anidadas tienen más sentido si tomamos como ejemplo, que, para
inscribir a una persona en ese centro educativo, además de pedir los datos que
necesitaríamos para cualquier compra en el súper mercado, también necesitamos
la fecha de nacimiento de la persona. Con esto, es necesario ingresar otro miembro
a la estructura.

Una estructura puede contener como miembro, un puntero para que apunte a una
estructura

Struct alumno

{char nombre [20];

char apellido [20];

int edad;

int anio;

int nota [4];

float promedio;

struct alumno *puntero;

};

Al introducir la sintaxis struct alumno *puntero se incorpora un miembro que

contendrá un puntero que apuntará hacia otra estructura del mismo tipo, y aquí a
cada estructura se le llama nodo.

Typedef.
La palabra reservada typedef proporciona un mecanismo para la creación de
sinónimos (o alias) para tipos de datos anteriormente definidos. Por ejemplo:

9
 Typedef struct ejemplo;

Define Ejemplo como un sinónimo de ejemplo. Una forma alternativa de definir una
estructura es:

typedef struct {

char c;

int i;} Ejemplo;

Podemos ahora utilizar Ejemplo para declarar variables del tipo struct, por ejemplo:

Ejemplo a [10];

Typedef se utiliza a menudo para crear seudónimos para los tipos de datos básicos.
Si tenemos por ejemplo un programa que requiere enteros de 4 bytes podría usar
el tipo int en un programa y el tipo Long en otro. Para garantizar portabilidad
podemos utilizar typedef para crear un alias de los enteros de 4 bytes en ambos
sistemas.

La declaración typedef proporciona una forma de crear un alias que se pueden

utilizar en cualquier lugar, en lugar de un nombre de tipo (posiblemente compleja).

Ejemplos usando estructuras:

En estos ejemplos se muestran declaraciones de estructura:

struct employee
{
char name [20];
int id;

Long class;

} temp;

10
La estructura llamada employee contiene tres miembros: name, id y class. El
miembro name es una matriz de 20 elementos, e id y class son miembros simples
con int y el tipo Long, respectivamente. El identificador employee es el identificador
de la estructura.

struct alumno

{char nombre [20];

char apellido [20];

int edad;

int año;

int nota [4];

float promedio;

};

Con la instrucción struct alumno declaro un tipo de dato llamado alumno, que
contendrá variables de tipo enteras, de punto flotante y cadenas de caracteres.

Ejemplo de un extracto de lo que sería estructuras anidadas:

typedef struct {

char texto [30];

int tipo;

} texto_t;

typedef struct {

texto_t nombre;

texto_t dirección;

} alumno;

11
Veamos un ejemplo completo:

12
Un aspecto muy importante a tener en cuenta, es que no se pueden comparar
estructuras entre sí, lo que sí se puede es comparar un miembro de una con el
mismo miembro de otra, esto es debido que los miembros no se almacenan en
forma consecutiva en memoria, sino que puede haber espacios de memoria vacíos
entre un miembro y otro de una misma estructura. Otro aspecto es que al ser la
estructura un tipo de dato, se puede pasar y recibir como argumento de una función
como si fuera un tipo de datos como los que ya fueron estudiados.

13
14
15
La variable amigo es de tipo estructura_amigo. Para acceder al nombre
de amigo usamos: amigo. nombre (al operador '.' le denominamos selector directo
de miembro) Vamos a ver un ejemplo de aplicación de esta estructura:

#include <stdio.h>

struct estructura_amigo { /* Definimos la estructura estructura_amigo */

char nombre [30];

char apellido [40];

char teléfono [10];

int edad;

};

struct estructura_amigo amigo; /* Declaramos la variable amigo con esa

estructura */

main ()

printf (“Escribe el nombre del amigo: “);

scanf (“%s", &amigo. nombre);

printf (“Escribe el apellido del amigo: “);

scanf (“%s", &amigo. Apellido);

printf (“Escribe el número de teléfono del amigo: “);

scanf (“%s", &amigo. Teléfono);

printf (“Mi amigo %s %s tiene el número: %s.\n", amigo. nombre,

amigo. Apellido, amigo. Teléfono);

16
 Conclusión

Las estructuras son conocidas como registros y pueden llegar a tener varios tipos
de datos. Para tener acceso a las estructuras se usa el operador punto, colocando
el nombre de la variable de tipo estructura, seguido de un punto, y seguido del
nombre del miembro de la estructura. Un aspecto muy importante al iniciar un struct,
es que gracias a typedef es posible definir sinónimos a los tipos de datos ya
existentes y con esto, colocar nombres más apropiados y entendibles.

La principal ventaja de usar estructuras reside en poder manejar dinámicamente el

espacio en memoria y, según la cantidad de registros que se quieran introducir, y
no un valor fijo como ocurre cuando se trabaja con arreglos. Se tiene que tomar en
cuenta que es posible anidar una estructura dentro de otra estructura, y por tanto
guardar juntos elementos asociados. Para finalizar se debe recalcar que los arreglos
de estructura como todos los demás arreglos son automáticamente pasados en
llamadas por referencia, y un dato muy importante es que los identificadores de
estructura deben ser distintos de otras etiquetas de estructura.

17
Anexos

18
 Bibliografía

https://docs.microsoft.com/es-es/cpp/c-language/structure-declarations?view=vs-
2019

https://www.cimat.mx/~pepe/cursos/lenguaje_2010/slides/slide_33.pdf

http://decsai.ugr.es/~jfv/ed1/c/cdrom/cap7/cap71.htm

http://programandoenc.over-blog.es/article-struct-o-estructuras-de-registros-en-c-
123607830.html

https://www.fing.edu.uy/tecnoinf/mvd/cursos/prinprog/material/teo/prinprog-
teorico08.pdf

https://arco.esi.uclm.es/~david.villa/pensar_en_C++/vol1/ch03s08s02.html

https://www.aprendeaprogramar.com/cursos/verApartado.php?id=16007

https://es.slideshare.net/carolina00/estructuras-en-c

https://kesquivel.files.wordpress.com/2013/05/estructuras2013final2.pdf

http://www.aprendeaprogramar.com/mod/forum/discuss.php?d=2145

http://sopa.dis.ulpgc.es/so/cpp/intro_c/introc57.htm

https://www.aulafacil.com/cursos/programacion/lenguaje-de-programacion-
c/inicializar-estructuras-l17609

http://c.conclase.net/curso/?cap=011

19