You are on page 1of 6

Lenguaje C

Estructuras
Al estudiar el capítulo de funciones, aprendimos la estrategia: Divide y Vencerás; ahora aprenderemos la inversa: La unión hace la
esfuerza, la cual se implementa, también, en dos pasos:
1)

Conocer las componentes (partes) individuales, lo cual ya lo hemos hecho, por ejemplo:
int
codigo;
char nombre[25];
int
edad;
Estas tres variables pueden referirse, por ejemplo, a un estudiante; pero no lo reflejan, les falta cohesión.

2) Cohesionar las componentes para formar una estructura con un nombre que represente la cohesión.
sintaxis de una estructura:
struct [MisDatos] {
tipo1 campo1;
tipo2 campo2;
….....
} [miDato1, miDato2, ….];
// Declaración de variables de tipo struct MisDatos
// note las partes [opcionales]
Donde:
MisDatos es el nombre de estructura
miDato1, miDato2, …. son variables del tipo struct MisDatos.
Es un error omitir las dos partes opcionales:
struct {
tipo1 campo1;
….....
};
Porque la estructura no tiene nombre, por lo tanto no puede ser referida.
Una estructura define a un tipo de dato complejo que agrupa a varios tipos de dato (simples o complejo); suele definirse como
global (antes de todas las funciones) para ser usada en todo el programa; recuerde que se recomendó reducir el uso de variables
globales.
¡Admírete, alégrate… !!!! Estamos usando magistralmente un principio fundamental de integración universal que lo usan todas las
ciencias, la gestión y el sentido común. Practíquelo y aplíquelo.
Atento: Este procedimiento da el fundamento lógico a la estrategia La unión hace la fuerza. Para aplicarlo a las ciencias sociales; se
debe complementar con los sentimientos: responsabilidad personal, complementariedad, afectos, etc.

Definición, referencia, lectura, escritura, asignación e impresión de variables de tipo struct
En lo posible estas operaciones son similares a las que se hacen con datos de tipo primario:
Donde es razonablemente claro utilizar la estructura, se la usa;
Si nó, se usan los campos de la estructura.
Definición de variables:
Se puedes definir de dos formas equivalentes:
struct Estudiantes {
int codigo;
char nombre[25];
} est1, …. ;
// forma 1
struct Estudiantes est2, ...;

// forma 2.

struct Estudiantes est3 = {124, "José Vargas"};

// define y asigna valores

est1.codigo = 123;
strcpy(est1.nombre, "María Mar");

// asina valor a la variable est1.codigo
// asina valor a la cadena est1.nombre

scanf(“%d”, &est1.codigo);
scanf(“%s”, est1.nombre);
printf(“%d”, est1.codigo);
printf(“%s”, est1.nombre);

// lee un entero
// lee una cadena

PÁGINA: 1

edad.Lenguaje C Ejemplo: struct Estudiantes { int codigo. &est[2]. est2.h> void main(void){ struct Estudiantes { int codigo. est2 y est3. "Carlos Rodríguez". asignar valores e imprimir datos a una esturctura #include<stdio.c: // Definir. Error: No compila est3.h> #include<string. char nombre[25]. // est3 = {125. est2.edad = 23. } Salida: Carlos Rodríguez José Vargas María Mar Arreglos de estructuras Se definen arreglos como de costumbre: struct Estudiantes { …. // no se asignó valores a est[2]. // asigna valores a est1 struct Estudiantes est2 = {124. char nombre[25]. char nombre[25]. // atento: nombre es un string est3. } est1. Ejemplo: Defina los estudiantes est1. 51}. 25}.nombre. } est1 = {123. }. "María Mar"). La definición anterior es equivalente a: struct Estudiantes { int codigo. est2. lea e imprima datos de una estructura. 25}. Programa 09_02.codigo). est3.nombre = “Juan Juan”. 23}. // Error: nombre es una cadena // Imprime est[2]. "Carlos Rodríguez".codigo = 125. } est[10]. // forma 2: arreglo de 2 elementos struct Estudiantes est[3] = {{123. // asignación a cada campo strcpy(est3. "María Mar"). int edad. {125.nombre).nombre Anidamientos de estructuras Una estructura puede anidarse dentro de otra.codigo est[2]. struct Estudiantes est1. est1. // forma 1: arreglo de 10 elementos struct Estudiantes est[2].h> void main(void){ struct Nombres { // estructura simple PÁGINA: 2 .nombre). asignar valores e imprimir datos de una estructura con anidamiento #include <stdio.nombre. // define la estructura // define las variables de tipo Estudiantes. se puede formar una cascada. est[2]. est3.h> #include <string. ejemplo: Defina. est3. int edad. printf(“%s”.nombre. // lee est[2]. est3.c: // Definir.nombre. 23}}. "José Vargas". scanf(“%d”. strcpy(est[2]. asigne valores e imprima los nombres: Programa 09_01. "María Mar". "María Mar". printf("%s\n%s\n%s\n".

campo1). &est2. // dato ocupará un área continua de de 4 + 25 = 29 bytes Se define un apuntador a la variable dato como de costumbre: struct Datos *pdato = &dato.campo1 = 123. } est1 ={123. dato. *pdato = &dato. sin embargo el if funciona bien.Lenguaje C char nombre[15].campo1)). scanf("%s". est2. "Romero"}. printf("%s\n". printf("Nombre: %s\n". struct Nombres nombre. se cumple: dato.nombre. est2. printf("\nReporte\n"). Ejemplo: Defina y utilice un apuntador a estructura. est2. por eso se usa & Mientras pdato apunte a dato. printf("Apellido: %s\n". // define dos variables y asigna valores a la primera printf("Codigo: ").nombre. Campo1 == (*pdato). scanf("%d". pdato->campo2).nombre. "100 Fuegos").h> #include<string. porque apuntan a la misma dirección Compila con warning debido a que pdato es un puntero de tipo Dato y &(dato. PÁGINA: 3 . printf("Edad: "). Atento.c: // Definir y utilizar un apuntador a estructura. strcpy(est2. // es true. &est2. char apellido[15]. printf("Nombre: "). scanf("%d". printf("Edad: %d\n". printf("%d\n".codigo).edad). 19}. } Salida: Codigo: 12 Nombre: Carlos Edad: 15 Reporte Codigo: 12 Nombre: Carlos Apellido: 100 Fuegos Edad: 15 Apuntadores a estructura Un apuntador puede apuntar a cualquier tipo de dato. if(pdato == &(dato. }. char campo2[25]. // define dato y *pdato (*pdato).codigo).(menos) seguido de > Se usa la flecha para hacer menos incómoda la notación de puntero. // dato no es un puntero. la instrucción: if(pdato == &(dato. struct Estudiantes { // estructura más compleja que anida int codigo. } dato.nombre. // asigna valores strcpy ( pdato->campo2.edad). {"José".campo1 == pdato->campo1 // la flecha se escribe: .apellido. est2. } dato. "hola" ). char campo2[25]. else printf("El if() no funciona\n").apellido). est2. Programa 09_03.nombre). ejemplo: struct Datos { int campo1.nombre).campo1)) printf("El if() funciona\n"). printf("Codigo: %d\n".campo1) es de tipo int. est2. // estructura simple anidada int edad. como sucede con un arreglo.h> void main(void){ struct Dato { int campo1. #include<stdio.

char nombre[]. lista++) printf( "%d\t\%s\n". struct Alumnos lista). while(getchar()!=10). codigo). lista->nombre).c: Argumento: 3) Arreglo de estructuras: lista #include<stdio. void leer (int *codigo. *n = 2. printf("Caracter2: ").struct Alumnos lista) { printf("-------\ncodigo nombre\n"). void main(void) { struct Alumnos lista1. struct Alumnos *lista).codigo. // atento al uso de & escribir(lista1. n). scanf("%d". while(getchar()!=10). } void leer(int *codigo. } void escribir(struct Alumnos *lista. codigo. lista. void leer (struct Alumnos *lista. i++. int n).nombre). &lista->codigo).nombre. } Salida: Campo1: 12 Campo2: José Campo1: 44 Campo2: Carlos ------Campo1 Campo2 12 José 44 Carlos PÁGINA: 4 . printf( "%d\t\%s\n". printf("-------\nCampo1 Campo2\n"). char nombre[]. i++.c: Argumentos: 1) Campos de estructura: lista1 2) Estructura: lista2 Programa 09_04b. void escribir(int codigo. // para limpiar el buffer scanf("%s". printf("Ingrese 2 estructuras\n").Lenguaje C } Salida: 123 hola El if() funciona Paso de argumentos de tipo estructura a funciones Leer y escribir datos de estructuras: Programa 09_04a. char nombre[].codigo. leer(&lista1. &lista->codigo). printf("Numero1 : ").h> #define MAX 10 #define LONGE 60 struct Alumnos{ int codigo. lista. struct Alumnos *lista) { printf("Ingrese 2 estructuras\n"). leer(lista.nombre). // atento al uso de & escribir(lista. int *n) { int i. lista1. char nombre[]. struct Alumnos lista[4]. // para limpiar el buffer scanf("%s". lista2). printf("Caracter: "). // para limpiar el buffer scanf("%s". while(getchar()!=10). char nombre[LONGE]. int n){ int i. printf("Numero2 : "). &n). scanf("%d". lista->nombre).codigo. }. scanf("%d". printf( "%d\t\%s\n". printf("Caracter1: "). lista++){ printf("Numero : "). &lista2). for(i=0. } void leer(struct Alumnos *lista. lista->nombre). nombre). } } } void escribir(int codigo.nombre. void main(void) { int n. int *n). i<*n. lista->codigo. i<n. void escribir(struct Alumnos *lista. for(i=0. lista1. lista2.

i<n. *plista[MAX]. imin. lista[n]. scanf("%s". void main(void){ struct Alumnos lista[MAX]. scanf("%d". int n). }. plista). int n). n). plista[n] = &lista[n]. int n=0.nombre) > 0){ imin = j. n = leer(lista. para finalizar (código = 0):\n").c: sin funciones Programa 09_05b. &lista[n]. for(i=0. } void ordenar(struct Alumnos *lista.Lenguaje C Ejercicio: Leer. int leer(struct Alumnos *lista. void main(void){ struct Alumnos lista[MAX]. j< n. } } PÁGINA: 5 . n++. do { printf ("Código: ").codigo == 0) break.h> #define MAX 10 #define LONGE 60 struct Alumnos{ int codigo.lista[j]. } if(imin > i){ plista[imin] = plista[i].i++) printf("\n%d\t%s". int i. plista. struct Alumnos **plista. void imprimir(struct Alumnos **plista. return n. } int leer(struct Alumnos *lista. i<n-1.codigo). ordenar (lista. } while (n<MAX). printf ("\nCódigo Nombre"). printf ("\n"). plista[i]->nombre). pmin = plista[i]. struct Alumnos **plista. *plista[MAX]. pmin = plista[j]. if(lista[n]. plista[i] = pmin. i++){ // ordenar punteros por nombre imin = i.codigo == 0) return n. for(j=i+1. j++) if(strcmp(pmin->nombre. printf ("Teclee Código y Nombre.c: con funciones #include<stdio. int n){ struct Alumnos *pmin. void ordenar(struct Alumnos *lista. int n){ int i. char nombre[LONGE]. ordenar y escribir arreglo de estructuras: Programa 09_05a. n). if(lista[n]. imin. struct Alumnos **plista){ int n = 0. struct Alumnos **plista). } } } void imprimir(struct Alumnos **plista. j. printf ("Nombre: "). int n. plista[i]->codigo. i. *pmin. j.nombre). imprimir(plista. for (i=0.

lea e imprima datos de una union. Referencia a los campos de uniones La notación para uniones es parecida a la de estructuras. }.campo1[1]).campo2[1]). // error lógico. PÁGINA: 6 . // asigna valor a campo1[1] = 4 printf("%lu\t %lu\n". Si en el momento 1 usará el campo2. …). pmiAhorro->campo2[0]. por ejemplo: union [Ahorro] { int campo1[8]. …. // variables de tipo union Ahorro El propósito de una union es ahorrar espacio de memoria. …. Una unión tiene una definición parecida. // define a las variables miAhorro y a pmiAhorro (puntero) pmiAhorro = &miAhorro.h> union Ahorro { int campo1[8]. campo2 no tendría el valor correcto.Lenguaje C Salida: Teclee Código y Nombre. miAhorro. // pmiAhorro apunta a miAhorro. *pmiAhorro. por ejemplo: struct Ahorro { int campo1[8]. No se produce error en tiempo de compilación.c: // Definir. El propósito de una estructura es contener todos los campos al mismo tiempo durante la ejecución de un programa. miAhorro. para finalizar (código = 0): Código: 10 Nombre: José Código: 12 Nombre: Carlos Código: 0 Código Nombre 12 Carlos 10 José Unión Hemos estudiado estructuras. } Salida: 4 6 25769803780 4195392 // error lógico: no se había asignado valor a campo2. long campo2[2]. en tiempo de ejecución contendrá un solo campo. pmiAhorro->campo1[0]. Programa 09_06. printf("%d\t %d\n". // asigna valor a campo1[0] = 4 pmiAhorro->campo1[1] = 6. lo mismo sucede si en el momento 2 usará el campo1. long campo2[6]. }. Es responsabilidad del programador que este error lógico (invisible) no suceda. por ejemplo: momento campo contenido 1 campo1: asigna valores a campo1 y usa campo1 2 campo2: asignar valores a campo2 y usa campo2. miAhorro. // el tamaño de esta union es 4 * 8 = 32 bytes void main(void){ union Ahorro miAhorro.campo1[0] = 4. el espacio de una unión es el máximo(campo1. long campo2[6]. pero los resultados serán incorrectos. Campo2. leer e imprimir datos de una union #include<stdio. } [miAhorro. es probable que no se produzca error en tiempo de ejecución.]. El espacio de una estructura es la suma de los espacios de todos los campos. ejemplo: ejemplo: Defina.