Estructuras de datos en Introducción a la Programación con C++

1. Introducción a la
Programación.
Tema: Estructuras de datos.
Unidad II: Elementos de Programación .

2. 2.8 Definición de arreglos unidimensionales y
bidimensionales.
2.9 Búsqueda, ordenación y mezcla de arreglos.
2.10 Estructura de datos.
2.11 Programación modular.
2.12 Definición de punteros.
2.13 Estructuras dinámicas.
Unidad II: Elementos de Programación

3. 2.10 Estructura de datos.
Objetivos:
Crear y utilizar estructuras, uniones y enumeraciones.
Pasar estructuras a funciones por valor y por
referencia
Unidad II: Elementos de Programación

4. Bibliografía
C++ para Ingeniería y
Ciencia. Editorial
Cengage Learning
Editores S. A. de C. V.
Segunda edición. 2007.
Gary J. Bronson.
Capítulo 13. Páginas:
711 - 719; 724 - 725.

5. Bibliografía
Cómo programar C/C+
+ y Java Introduccción al
análisis y diseño.
Editorial Pearson
Prentice Hall Cuarta
edición. 2004. Deitel.
Deitel. Capítulo 10.
Páginas: 355 – 358, 364

6. Bibliografía
El lenguaje de
programación C. Con base
en el ANSI C. Editorial
Pearson Prentice Hall
Segunda edición. 1991.
Brian W. Kernighan,
Dennis M. Ritchie.
Capítulo 6. Páginas: 141 –
142, 162

7. Bibliografía
Fundamentos de
Programación con el
Lenguaje de Programación
C++. Dpto. Lenguajes y
CC. Computación E.T.S.I.
Informática. 2017. Vicente
Benjumea y Manuel
Roldán. Capítulo 6.
Páginas: 64-65.

8. Introducción.
Las estructuras, conocidas también como
agregados o registros, son colecciones de
variables relacionadas bajo un nombre. Ellas
pueden contener variables de diferentes tipos
de datos, a diferencia de los arreglos, los cuales
sólo contienen elementos del mismo tipo.
Generalmente se utilizan para definir registros
que van a almacenarse en archivos. Los
apuntadores y las estructuras facilitan la
formación de estructuras de datos más
complejas, como listas enlazadas, colas, pilas y
árboles.

9. Estructuras.
Una estructura es un vestigio histórico de
C. A la estructura se le denomina y es lo
mismo que un registro. En C y C++, una
estructura proporciona un medio para
almacenar valores que tienen diferentes
tipos de datos, como un número de parte
entero, un tipo parte en carácter y un
suministro de voltaje en número de
precisión doble.

10. Estructuras.
Como ya se sabe, representan un valor compuesto por
un número determinado de elementos, que pueden ser de
distintos tipos (simples y compuestos). Para utilizar
registros se define un nuevo tipo registro, enumerando
los elementos (campos) que lo componen. Para cada
campo debe indicarse su tipo y el identificador con el que
le referiremos. La definición del tipo registro se hará
utilizando la palabra reservada struct, seguido del
identificador con el que haremos referencia a dicho tipo. A
continuación se enumeran, entre llaves, los campos que
lo componen, especificando su tipo y el identificador
con el que referenciarlo, seguido por el delimitador punto
y coma (;). La llave de cierre debe ir seguida de punto y
coma.

11. Estructuras.
Un ejemplo tradicional de estructura es el registro
de una nómina: un empleado está descrito por un
conjunto de atributos, como nombre, domicilio,
número del seguro social, salario, etc. Algunos de
estos atributos pueden, a su vez, ser estructuras:
un nombre tiene varios componentes, como los
tiene un domicilio y aún un salario. Otro ejemplo,
más típico para C, procede de las gráficas: un
punto es un par de coordenadas, un rectángulo
es un par de puntos, y otros casos semejantes.

12. Ejemplo de estructuras.
Suponga que un fabricante de circuitos
integrados (CI) mantiene un resumen de
información para cada uno de los circuitos
que fabrica. Los elementos de datos
conservados para cada circuito son:
Número de parte:
Familia de circuitos integrados:
Tipo de función:
Suministro de voltaje:
Unidades en existencia:

13. Ejemplo de estructuras.
Cada uno de los elementos de datos individuales
enlistados antes, es una entidad en sí mismo que se
conoce como un campo de datos. En conjunto, todos los
campos de datos forman una sola unidad que se denomina
estructura. Aunque el fabricante de circuitos integrados
podría dar seguimiento a cientos de componentes, la forma
de cada estructura de carácter es idéntica. Al tratar con
estructuras es importante distinguir entre la forma de una
estructura y su contenido. La forma de una estructura
consiste en los nombres simbólicos, tipos de datos y el
orden de los campos de datos individuales en la estructura.
El contenido de la estructura se refiere a los datos reales
almacenados en los nombres simbólicos.

14. Ejemplo de estructuras.
Contenidos aceptables para la forma de
estructura son los siguientes:
Número de parte: 23421
Familia de circuitos integrados: TTL
Tipo de función: AND
Suministro de voltaje: 6.0
Unidades en existencia: 345

15. Instrucciones de C++ para las estructuras.
Existe una serie de instrucciones de C++ requeridas
para crear, llenar, usar y transmitir estructuras entre
funciones.
1. Crear y usar una estructura requiere los mismos dos
pasos necesarios para crear y usar cualquier variable.
a) Primero debe declararse la estructura del
registro.
b) Luego pueden asignarse valores específicos a
los elementos individuales de la estructura.
2. Declarar una estructura requiere enlistar los tipos
de datos, los nombres de datos y el orden de los
elementos de datos.

16. Ejemplo de estructura en C++
struct empleado
{char
nombre[ 20 ];
char
apellido[ 20 ];
int edad;
char sexo;
double
salarioPorHora;};
struct empleado
{char
nombre[ 20 ];
char
apellido[ 20 ];
int edad;
char sexo;
double
salarioPorHora;};
Las estructuras son tipos de
datos derivados, que se
construyen por medio de
objetos de otros tipos.
Un error común de
programación es olvidar el
punto y coma al finalizar la
definición de una estructura,
es un error de sintaxis.

17. Ejemplo de estructura en C++
struct empleado
{char
nombre[ 20 ];
char
apellido[ 20 ];
int edad;
char sexo;
double
salarioPorHora;};
struct empleado
{char
nombre[ 20 ];
char
apellido[ 20 ];
int edad;
char sexo;
double
salarioPorHora;};
Contiene miembros que son
arreglos de caracteres para el
nombre y el apellido, y un
miembro int para la edad, un
miembro char ( ‘M’ o ‘F’) para
el sexo, y un miembro double
para el salario por hora.
Una estructura no puede
contener una instancia de sí
misma. Por ejemplo, una
variable de tipo struct empleado
no puede declararse en la
definición de struct empleado.

18. Ejemplo de estructura en C++
struct empleado
{ char nombre[ 20 ];
char apellido[ 20 ];
int edad;
char sexo;
double salarioPorHora;
struct empleado persona; /*ERROR*/
};
struct empleado
{ char nombre[ 20 ];
char apellido[ 20 ];
int edad;
char sexo;
double salarioPorHora;
struct empleado persona; /*ERROR*/
};

19. Ejemplo de estructura en C++
struct Fecha {
unsigned dia;
unsigned mes;
unsigned anyo;} ;
struct Fecha {
unsigned dia;
unsigned mes;
unsigned anyo;} ;
Para representar fechas,
dadas por tres números
que representan un
cierto día de un mes de
un año.
Luego, podrá ser utilizado, para definir constantes
simbólicas, variables o parámetros formales en
los subprogramas. Por ejemplo, puede utilizar el
nuevo tipo Fecha para definir variables: Fecha
f_ingreso; o para definir constantes: const Fecha
F_NAC = { 25, 12, 1};

20. Ejemplo de estructura en C++
struct Fecha
{unsigned dia;
unsigned mes;
unsigned anyo;} ;
struct Fecha
{unsigned dia;
unsigned mes;
unsigned anyo;} ;
Los valores de tipo
estructurado están formados
por diferentes componentes,
por lo es necesaria alguna
notación especial para indicar
claramente el valor de cada
una de ellos.
Como se puede observar, el valor que toma la
constante const Fecha F_NAC = { 25, 12, 1}; se
expresa enumerando y separando por comas
los valores que se asignan a los campos (en
el mismo orden de la definición del tipo registro) y
utilizando llaves para agruparlo todo.

21. Ejemplo de estructura en C++
struct Fecha
{unsigned dia;
unsigned mes;
unsigned anyo;} ;
struct Fecha
{unsigned dia;
unsigned mes;
unsigned anyo;} ;
Una vez declarada una entidad
(constante o variable) de tipo
estructura, por ejemplo la variable
f_ingreso, puede referirse a ella
(realizando asignaciones y pasos
de parámetros) o acceder a sus
componentes (campos) utilizando
el operador punto (.).
Una vez que se accede a un
determinado campo se tiene un
valor del tipo de dicho campo,
por lo que podrá ser utilizado de
acuerdo con las características
de dicho tipo, como si se tratase
de una variable de dicho tipo.
int main ()
{Fecha f_nac, hoy ;
hoy.dia = 18 ; hoy.mes = 10 ;
hoy.anyo = 2001 ;
f_nac = hoy ;}
int main ()
{Fecha f_nac, hoy ;
hoy.dia = 18 ; hoy.mes = 10 ;
hoy.anyo = 2001 ;
f_nac = hoy ;}

22. Buenas prácticas de programación
Cuando genere un tipo de estructura, siempre
proporcione una etiqueta con su nombre.
Dicha etiqueta es conveniente para que
posteriormente se declaren nuevas variables
correspondientes a la estructura.
Elegir una etiqueta con un nombre
significativo ayuda que un programa esté
autodocumentado.
Cuando genere un tipo de estructura, siempre
proporcione una etiqueta con su nombre.
Dicha etiqueta es conveniente para que
posteriormente se declaren nuevas variables
correspondientes a la estructura.
Elegir una etiqueta con un nombre
significativo ayuda que un programa esté
autodocumentado.

23. Definición de la forma de la estructura
struct
{ int mes;
int dia;
int anio;
} nacimiento;
struct
{ int mes;
int dia;
int anio;
} nacimiento;
La definición da la forma de
una estructura llamada
nacimiento y reserva
almacenamiento para los
elementos de datos individuales
enlistados en la estructura. La
estructura nacimiento consiste en
tres elementos de datos o
campos, los cuales se
denominan miembros de la
estructura.

24. Definición de la forma de la estructura
Asignar valores de datos reales a los elementos de datos
de una estructura se conoce como poblar la estructura
y es un procedimiento relativamente sencillo. Se tienen
acceso a cada miembro de una estructura dando tanto el
nombre de la estructura como el nombre del elemento
de datos individual, separado por un punto. Por tanto:
 nacimiento.mes se refiere al primer miembro de la
estructura nacimiento.
 nacimiento.dia se refiere al segundo miembro de la
estructura.
nacimiento.anio se refiere al tercer miembro.

25. Programa que asigna valores a estructura.
#include <iostream>
using namespace std;
int main()
{ struct { int month; int day; int year; } birth;
birth.month = 12;
birth.day = 25;
birth.year = 1;
cout << "Mi cumpleaños es " << birth.month << '/'
<< birth.day << '/' << birth.year <<endl;}

26. Programa que asigna valores a estructura.
La salida producida por el programa es Mi
fecha de nacimiento es 12/25/1
Como en la mayor parte de las
instrucciones en C++, el espaciamiento en
la definición de una estructura no es
rígido. También pueden definirse
múltiples variables en la misma
instrucción. Por ejemplo:

27. struct
{ int mes;
int dia;
int anio;
} nacimiento,
actual;
struct
{ int mes;
int dia;
int anio;
} nacimiento,
actual;
Esta definición crea dos
variables de estructura que
tienen la misma forma. Se hace
referencia a los miembros de la
primera estructura con los
nombres individuales
nacimiento.mes, nacimiento.dia y
nacimiento.anio, mientras que se
hace referencia a los miembros
de la segunda estructura con los
nombres actual.mes, actual.dia y
actual.anio.
Programa que asigna valores a estructura.

28. struct
{ int mes;
int dia;
int anio;
} nacimiento,
actual;
struct
{ int mes;
int dia;
int anio;
} nacimiento,
actual;
La forma de esta instrucción
de definición de una
estructura particular es
idéntica a la forma usada al
definir cualquier variable de
programa: el tipo de datos
es seguido por una lista de
nombres de variables.
Programa que asigna valores a estructura.

29. struct Fecha
{ int mes;
int dia;
int anio;
};
struct Fecha
{ int mes;
int dia;
int anio;
};
Una modificación útil y muy
usada para definir tipos de
estructura es enlistar la forma
de la estructura sin que le sigan
los nombres de variables. En
este caso, sin embargo, la lista
de los miembros de la estructura
debe ser precedida por un
nombre de tipo de datos
seleccionado por el usuario.
Programa que asigna valores a estructura.

30. struct
Fecha
{ int mes;
int dia;
int anio;
};
struct
Fecha
{ int mes;
int dia;
int anio;
};
Aquí, la declaración para la estructura
Fecha crea un tipo de datos nuevo sin
reservar en realidad ninguna
ubicación de almacenamiento. No es
una instrucción de definición. Sólo
declara un tipo de estructura Fecha y
describe cómo se ordenan los
elementos de datos individuales dentro
de la estructura. El almacenamiento
real para los miembros de la
estructura sólo se reserva cuando se
asignan nombres de variable
específicos. Por ejemplo: Fecha
nacimiento, actual;
Programa que asigna valores a estructura.

31. struct Reg_pago
{ string nombre;
int num_id;
double
tarifa_normal;
double
tarifa_textra;};
struct Reg_pago
{ string nombre;
int num_id;
double
tarifa_normal;
double
tarifa_textra;};
Considérese un registro de
empleados consistente en los
siguientes elementos de datos:
Nombre:
Número de identificación:
Tarifa de pago normal:
Tarifa de pago de tiempo
extra:
Una declaración adecuada para
estos elementos de datos es:
Otro ejemplo de estructura.

32. Una vez que se ha declarado el tipo de datos
Reg_pago, puede definirse e inicializarse una
variable de estructura específica usando este
tipo. Por ejemplo, la definición
Reg_pago empleado = {“H. Price”, 12387, 15.89,
25.50};
crea una estructura llamada empleado del tipo de
datos de Reg_pago, que se inicializa con listas de
inicialización, como en los arreglos. Los miembros
individuales de empleado se inicializan con los
datos respectivos enlistados entre llaves en la
instrucción de definición.
Otro ejemplo de estructura.

33. Vale la pena señalar que los miembros individuales
de una estructura pueden ser cualquier tipo de
datos válido en C++, incluyendo arreglos y
estructuras. Se usó un arreglo de caracteres como
un miembro de la estructura empleado definida con
anterioridad. Para tener acceso a un elemento de un
arreglo miembro se requiere dar el nombre de la
estructura, seguido por un punto, seguido por la
designación del arreglo. Incluir una estructura
dentro de una estructura sigue las mismas reglas
para incluir cualquier tipo de datos en una estructura.
Otro ejemplo de estructura.

34. Suponga una estructura
consiste en un nombre y una
fecha de nacimiento, donde
se ha declarado una
estructura Fecha como:
struct Datos {int mes; int
dia; int anio;};
Una definición adecuada de
una estructura que incluya un
nombre y una estructura de
Fecha es:
Estructuras dentro de estructura.
struct
{ struct Datos
string
nombre;
Fecha
nacimiento;
} persona;
struct
{ struct Datos
string
nombre;
Fecha
nacimiento;
} persona;

35. Observe que al declarar la estructura Fecha, el término
Fecha es el nombre de un tipo de datos; por tanto
aparece antes de las llaves en la instrucción de
declaración. Al definir la variable de estructura para
persona, persona es un nombre de variable; por tanto
es el nombre de una estructura específica. Lo mismo
sucede con la variable llamada nacimiento. Éste es el
nombre de una estructura Fecha específica. Se tiene
acceso a los miembros individuales en la estructura
persona precediendo al miembro deseado con el
nombre de la estructura seguido por un punto. Por
ejemplo, persona.nacimiento.mes se refiere a la
variable mes en la estructura nacimiento contenida en la
estructura persona.
Estructuras dentro de estructura.

36. 1. Declare un tipo de estructura de datos para cada uno de los
siguientes registros:
a. El registro de un estudiante que consiste en un número de
identificación del estudiante, número de créditos completados
y el promedio acumulado de puntos de calificación.
b. El registro de un estudiante que consiste en el nombre de
un estudiante, la fecha de nacimiento, el número de créditos
completados y el promedio acumulado de puntos de
calificación.
c. Un registro de acciones que consiste en el nombre de la
acción, el precio de la acción y la fecha de compra.
e. Un registro de inventario que consiste en un número de
parte entero, la descripción de la parte, el número de partes
en el inventario y un número entero para reordenar
Ejercicios con estructuras.

37. 2.Escriba un programa en C++ que acepte una
fecha introducida por el usuario. Haga que el
programa calcule y despliegue la fecha del día
siguiente. Suponga que todos los meses constan
de 30 días.
3.Modifique el programa escrito en el ejercicio 2
para que dé cuenta del número real de días en
cada mes.
4. Cree una estructura la cual contenga: apellido,
nombre, numeroCliente, numeroTelefonico,
direccion (la cual a su vez es otra estructura que
contiene ciudad, estado y codigoPostal.
Ejercicios con estructuras.

38. Estructuras como argumentos de función.
Los miembros individuales
de estructura pueden
transmitirse a una función de
la misma manera que
cualquier variable escalar.
desplegar(empl.num_id);
transmite una copia del
miembro de la estructura
empl.num_id a una función
llamada desplegar().
struct
Empleado
{
int num_id;
double
tarifaPago;
double
horas;
}empl;
struct
Empleado
{
int num_id;
double
tarifaPago;
double
horas;
}empl;

39. Estructuras como argumentos de función.
calcPago(empl.tarifaPago,e
mpl.horas); transmite copias
de los valores almacenados
en los miembros de la
estructura empl.tarifaPago y
empl.horas a la función
calcPago(). Ambas funciones,
desplegar() y calcPago(),
deben declarar los tipos de
datos correctos para sus
respectivos argumentos.
struct
Empleado
{
int num_id;
double
tarifaPago;
double
horas;
}empl;
struct
Empleado
{
int num_id;
double
tarifaPago;
double
horas;
}empl;

40. Estructuras como argumentos de función.
También pueden transmitirse
copias completas de todos los
miembros de una estructura a una
función al incluir el nombre de la
estructura como un argumento para
la función llamada. Por ejemplo:
calcNeto(empl); transmite una
copia de la estructura empl
completa a calcNeto(). Dentro de
calcNeto() debe hacerse una
declaración apropiada para recibir
la estructura.
struct
Empleado
{
int num_id;
double
tarifaPago;
double
horas;
}empl;
struct
Empleado
{
int num_id;
double
tarifaPago;
double
horas;
}empl;

41. Estructuras como argumentos de función.
#include <iostream>
#include <iomanip>
using namespace std;
struct Empleado // declara un tipo global
{ int num_id; double tarifaPago; double horas; };
double calcNeto(Empleado); // prototipo de la funcion
int main() {Empleado empl = {6782, 8.93, 40.5}; double pagoNeto;
pagoNeto=calcNeto(empl);//transmite copias de valores en empl
//establece formatos de salida
cout << setw(10) << setiosflags(ios::fixed) <<
setiosflags(ios::showpoint) << setprecision(2);
cout << “El pago neto para el empleado ” << empl.num_id
<< “ es $” << pagoNeto << endl; return 0;}
double calcNeto(Empleado temp)//temp es del tipo de datos
//Empleado
{ return temp.tarifaPago * temp.horas;}

42. Estructuras como argumentos de función.
El programa declara un tipo
de datos global para una
estructura de empleados.
Este tipo es usado
entonces por las funciones
main() y calcNeto() para
definir estructuras
específicas con los
nombres empl y temp,
respectivamente. La salida
sería: El pago neto para el
empleado 6782 es $361.66
El programa declara un tipo
de datos global para una
estructura de empleados.
Este tipo es usado
entonces por las funciones
main() y calcNeto() para
definir estructuras
específicas con los
nombres empl y temp,
respectivamente. La salida
sería: El pago neto para el
empleado 6782 es $361.66

43. Estructuras como argumentos de función.
Tanto main() como calcNeto()
usan el mismo tipo de datos para
definir sus variables individuales
de estructura. La variable de
estructura definida en main() y la
variable de estructura definida en
calcNeto() son dos estructuras
completamente diferentes. Los
cambios hechos a la variable
local temp en calcNeto() no se
reflejan en la variable empl de
main(). De hecho, dado que
ambas variables de estructura
son locales para sus respectivas
funciones.
Tanto main() como calcNeto()
usan el mismo tipo de datos para
definir sus variables individuales
de estructura. La variable de
estructura definida en main() y la
variable de estructura definida en
calcNeto() son dos estructuras
completamente diferentes. Los
cambios hechos a la variable
local temp en calcNeto() no se
reflejan en la variable empl de
main(). De hecho, dado que
ambas variables de estructura
son locales para sus respectivas
funciones.

44. Uniones.
Una unión es una variable que puede
contener (en momentos diferentes) objetos
de diferentes tipos y tamaños, y el
compilador hace el seguimiento del tamaño
y requisitos de alineación. Las uniones
proporcionan una forma de manipular di
ferentes clases de datos dentro de una
sola área de almacenamiento, sin incluir
en el programa ninguna información
dependiente de la máquina.

45. Uniones.
Son un tipo de dato derivado, como una estructura, con
miembros que comparten el mismo espacio de
almacenamiento. Para diferentes situaciones en un
programa, algunas variables podrían no ser importantes, pero
otras sí; por tanto, una unión comparte el espacio, en lugar de
desperdiciar espacio en variables que no se están utilizando.
Los miembros de una unión pueden ser de cualquier tipo.
El número de bytes utilizado para almacenar una unión debe
ser suficiente para almacenar al menos el miembro más
grande. En la mayoría de los casos, las uniones contienen
dos o más tipos de datos. Se puede hacer referencia
solamente a un miembro a la vez, y por lo tanto a un tipo de
dato a la vez. Es responsabilidad del programador garantizar
que se haga referencia a los datos de una unión con el tipo
de dato apropiado.

46. Se declara con la palabra
reservada unión, en el mismo
formato que una estructura. La
definición de unión indica que
numero es un tipo unión con los
miembros int x y double y. La
definición de una unión
normalmente se coloca en un
encabezado y se incluye en
todos los archivos fuente que
utilizan ese tipo de unión.
Ejemplo de uniones.
union
numero {
int x;
double y;
};
union
numero {
int x;
double y;
};

47. En una declaración, una unión puede
inicializarse con un valor del mismo
tipo que el primer miembro de la unión.
Por ejemplo, con la unión anterior, la
declaración union numero valor =
{ 10 }; es una inicialización válida para
una variable unión, ya que ésta se
inicializa con un int, sin embargo, la
siguiente declaración truncaría la parte
de punto flotante del inicializador, y
normalmente produciría una adver
tencia por parte del compilador: union
numero valor = { 1.43 };
Ejemplo de uniones.
union
numero {
int x;
double y;
};
union
numero {
int x;
double y;
};