Guía práctica de estudio 13: Estructuras - Sitio Odin.fi

Guía práctica de estudio 13:
Estructuras
Elaborado por:
M.C. Edgar E. García Cano
Ing. Jorge A. Solano Gálvez
Revisado por:
Ing. Laura Sandoval Montaño
Guía práctica de estudio 13: Estructuras
Objetivo:
Elaborar programas en C que requieran agrupar datos de diferentes tipos, definiendo
estructuras tanto simples como compuestas.
Introducción
Una estructura es una colección de una o más variables, de iguales o diferentes tipos,
agrupadas bajo un solo nombre, es decir, es un tipo de dato compuesto que permite
almacenar un conjunto de datos de diferente tipo (agrupar un grupo de variables
relacionadas entre sí) que pueden ser tratadas como una unidad (bajo un mismo nombre).
Las estructuras pueden contener tipos de datos simples y tipos de datos compuestos. Los
tipos de datos simples (o primitivos) son: carácter, números enteros o números de punto
flotante. Los tipos de datos compuestos son: los arreglos y las estructuras.
Licencia GPL de GNU
El software presente en esta guía práctica es libre bajo la licencia GPL de GNU, es decir, se
puede modificar y distribuir mientras se mantenga la licencia GPL.
/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Author: Jorge A. Solano
1
Estructuras
La sintaxis para definir una estructura en lenguaje C es la siguiente:
struct nombreEstructura {
// elemento(s) de la estructura
}
Es decir, se declara utilizando la palabra reservada struct seguida del nombre de la
estructura; entre las llaves se declaran las variables (simples o compuestas) que va a
contener la estructura.
Debido a que una estructura es un tipo de dato compuesto (compuesta por otras
variables), su alcance (o ámbito) está definido por el lugar donde se declara, es decir, una
estructura declarada fuera de cualquier función es global (cualquier función puede acceder
a ella), una estructura declarada dentro de una función solo se puede utilizar dentro de
dicha función.
Una vez definida una estructura, es posible crear variables de ese tipo de la siguiente
manera:
struct nombreEstructura nombreVariable;
Donde nombre de la variable es un identificador. Para acceder a los elementos de la
estructura se utiliza el nombre de la variable seguido de un punto seguido del nombre del
elemento de la estructura al que se desee acceder, es decir:
<tipoDato> var = nombreVariable.nombreElemento;
nombreVariable.nombreElemento = <tipoDato>;
2
Código (estructura simple)
#include <stdio.h>
/*
Este programa permite manejar las coordenadas de un punto en
el espacio de dos dimensiones a través de una estructura.
*/
struct punto {
int x;
int y;
};
int main () {
struct punto p = {5, 3};
printf("x = %d\n",p.x);
printf("y = %d\n",p.y);
return -0;
}
NOTA: Las variables de tipo estructura pueden ser globales o locales. En el ejemplo la
variable p es local; si esa declaración se realiza fuera de la función la variable sería global.
También se puede definir la estructura y al final, entre la llave que cierra la estructura y el
punto y coma, definir una variable.
3
Código (estructura compuesta)
#include<stdio.h>
/*
Este programa permite manejar el nombre y la contraseña de un
alumno a través de una estructura.
*/
struct alumno{
int num_cuenta;
char nombre[50];
};
int main() {
struct alumno a;
printf("Introduce tu nombre: ");
scanf("%s", a.nombre);
printf("Introduce tu número de cuenta: ");
scanf("%d", &a.num_cuenta);
printf("Alumno: %s\nNúmero de cuenta: %d\n",a.nombre, a.num_cuenta);
return 0;
}
NOTA: Es posible crear arreglos de estructuras, es decir, si en lugar de crear un alumno se
desea crear un grupo, la sintaxis sería la siguiente:
struct alumno grupo[10]
En este caso, cada elemento del arreglo grupo (grupo[0], grupo[1], grupo[2], etc.) sería un
alumno.
4
Código (estructura compuesta)
#include<stdio.h>
/*
Este programa permite crear un rectángulo a través de dos puntos en el
espacio de dos dimensiones mediante dos estructuras.
*/
struct punto {
int x, y;
};
struct rectangulo {
struct punto a, b;
};
int main() {
struct rectangulo r;
struct punto uno = {5,3}, dos = {8,6};
r.a = uno;
r.b = dos;
printf("Punto A: x = %d, y = %d\n", r.a.x, r.a.y);
printf("Punto B: x = %d, y = %d\n", r.b.x, r.b.y);
return 0;
}
5
Código 1 (funciones con estructuras)
#include<stdio.h>
/*
Este programa consta de tres funciones: main, crearPunto y sumarPuntos.
crearPunto genera una estructura punto con las coordenadas ‘x’ y ‘y’.
sumarPuntos recibe dos puntos como parámetros de entrada y los suma.
*/
struct punto {
int x, y;
};
struct punto sumarPuntos(struct punto uno, struct punto dos);
struct punto crearPunto(int x, int y);
int main() {
struct punto a, b, c;
a = crearPunto(5,5);
b = crearPunto(10,10);
c = sumarPuntos(a, b);
printf("C (%d,%d) = A (%d,%d) y B (%d, %d)\n",c.x, c.y, a.x, a.y, b.x, b.y);
return 0;
}
struct punto crearPunto(int x, int y) {
struct punto temporal;
temporal.x = x;
temporal.y = y;
return temporal;
}
struct punto sumarPuntos(struct punto uno, struct punto dos) {
uno.x += dos.x;
uno.y += dos.y;
return uno;
}
NOTA: Debido a que las funciones utilizan la estructura punto, primero se debe declarar
la estructura y luego las funciones al iniciar el programa.
6
Código 2 (funciones con estructuras)
#include <stdio.h>
/*
Este programa consta de tres funciones: main, crearPunto y ptoEnRect.
crearPunto genera una estructura punto con las coordenadas ‘x’ y ‘y’.
ptoEnRect permite validar si el punto que recibe como parámetro está
dentro del triángulo que recibe como parámetro, regresando verdadero (1)
o falso(0) según sea el caso.
*/
struct punto {
int x, y;
};
struct rectangulo {
struct punto a, b;
};
struct punto crearPunto(int x, int y);
int ptoEnRect(struct punto, struct rectangulo);
int main() {
struct rectangulo rect;
struct punto p, a, b;
p = crearPunto(14,5);
rect.a = crearPunto(0,0);
rect.b = crearPunto(9,9);
if ( ptoEnRect(p,rect) == 1 ) {
printf("El punto (%d,%d) se encuentra dentro del rectángulo\n",p.x,p.y);
} else {
printf("El punto (%d,%d) se encuentra fuera del rectángulo\n",p.x,p.y);
}
return 0;
}
struct punto crearPunto(int x, int y) {
struct punto temporal;
temporal.x = x;
temporal.y = y;
return temporal;
}
int ptoEnRect(struct punto a, struct rectangulo y) {
if ((y.a.x < a.x && a.x < y.b.x) && (y.a.y < a.y && a.y < y.b.y)) {
7
return 1;
} else {
return 0;
}
return 0;
}
Bibliografía
El lenguaje de programación C. Brian W. Kernighan, Dennis M. Ritchie, segunda edición,
USA, Pearson Educación 1991.
8