Estructurando Datos en el Lenguaje

➢ Concepto.
Una estructura de datos es un grupo de elementos de datos agrupados bajo
un solo nombre. Estos elementos de datos, conocidos como miembros, los
miembros pueden ser:
1. Variables, estas pueden tener diferentes tipos y longitudes.
2. Funciones.

➢ Declaración de tipos struct.

Para la declaración de un tipo estructura se emplea la palabra reservada
struct, la sintaxis para declarar una estructura es como se muestra a
continuación.
struct identificador_tipo

{
tipo_dato_miembro identificador_mienbro1;
tipo_dato_miembro identificador_mienbro2;
tipo_dato_miembro identificador_mienbro3;
.
.
};

Donde:
1. struct es una palabra reservada del lenguaje emplead para definir
estructura.
2. identificador_tipo es el nombre dado a la estructura declarada.
3. El bloque asociado a la estructura {} delimita el ámbito o alcance de
la estructura conteniendo dentro una lista de los miembros de datos.

4. tipo_dato_miembro puede ser cualquier tipo de dato definido por el

lenguaje o un tipo de dato definido o declarado por el programador.
5. identificador_mienbro es el nombre asociado a la variable miembro.

6. Al final de la llave cerrada que delimita la declaración de la

estructura se debe colocar un punto y coma (;).

Ejemplo de declaración de Estructura.

struct producto
{
int peso; Declaración de la estructura
duuble precio;
};
producto melon; Declaración de identificadores (variables) de tipo la
producto naranja; estructura declarada.
➢ Miembros de la estructura.
Los miembros de la estructura como se menciono anteriormente pueden
estar compuestos (en su forma más simple) por:
1. variables y
2. funciones
Ejemplo de declaración de Estructura.
struct producto
Para este caso, la estructura producto posee dos(2)
{
miembros que son : peso y precio. Notar que son
int peso;
identificadores declarados dentro del ámbito de la
duble precio;
estructura.
};
producto melon; Declaración de identificadores (variables) de tipo la
producto naranja; estructura declarada.

➢ Operaciones de acceso y manipulación de sus miembros con el

operador de punto.
1. Operaciones de acceso.
Para acceder a los miembros de una estructura debemos crear una
variable del tipo la estructura.

Para acceder a los miembros de la estructura se emplea la variable

declarada del tipo de la estructura seguido por el operador punto(.) y
a continuación el nombre del atributo miembro.

Ejemplo.
producto arroz; // Declaración de variable arroz del tipo la estructura producto.
arroz.peso = 1; // Para acceder al miembro peso se emplea la variable tipo la
estructura( arroz ) seguida del operador punto y luego el
identificador del miembro al cual se quiere acceder.
arroz.precio = 30;

2. Manipulación de sus miembros con el operador de punto.

Para manipular los valores de los miembros del tipo la estructura
podemos emplear los operadores de asignación.

Ejemplo.
arroz.peso = 1; //Asigna el valor 1 a la variable arroz la cual es del tipo la
estructura producto.
++arroz.peso; // Incrementa en 1 el valor del miembro peso de la variable arroz.
Un ejemplo completo:

#include <iostream>
#include <string>

using namespace std;

struct sPersona
{
string cedula;
string nombre;
string lugarNacimiento;
string fechaNacimiento;
string nacionalidad;
};

int main()
{

sPersona persona1;

persona1.cedula = "00145685239";
persona1.nombre = "Juan Perez";
persona1.lugarNacimiento = "Barahona";
persona1.fechaNacimiento = "19800130";
persona1.nacionalidad = "Dominicano";
persona1.sexo = 1;
persona1.sangre = 4;
persona1.estadoCivil = 3;

cout << endl

<< " Persona " << endl
<< "----------------- " << endl
<< " Cedula : " << persona1.cedula << endl
<< " Nombre : " << persona1.nombre << endl
<< "Lugar Nacimiento : " << persona1.lugarNacimiento << endl
<< " Nacionalidad : " << persona1.nacionalidad << endl
<< " Sexo : " << sexo[ persona1.sexo - 1] << endl
<< " Tipo Sangre : " << tipoSangre[ persona1.sangre - 1 ] << endl
<< " Estado Civil : " << estadoCivil[ persona1.estadoCivil - 1 ] << endl
<< endl;

return 0;
}
➢ Arreglos inteligentes de tipo de struct para simular proceso de
registros en un “archivo en RAM”
Se pueden declarar arreglos tipo estructura, las estructuras no son más que
tipos de datos nuevos declarados por el programador.

Ejemplo.

struct sPersona
{
string cedula;
string nombre;
};

sPersona arrPersona[3];

arrPersona[3]
arrPersona arrPersona arrPersona
[0] [1] [2]
Cedula : 123 Cedula : 224 Cedula : 325
Nombre : Juan Nombre : Manuel Nombre : Arquimedes

➢ Como acceder a los miembros de un arreglo tipo estructura empleando la

notación punto.
arrPersona[0].cedula = “123”;
arrPersona[0].nombre = “Juan”;

arrPersona[1].cedula = “224”;
arrPersona[1].nombre = “Manuel”;

arrPersona[2].cedula = “325”;
arrPersona[2].nombre = “Arquimedes”;

➢ De igual forma se pude declarar:

1. Un arreglo del tipo estructura empleando la librería array
Ejemplo de acceso a los elementos del array empleando la
función miembro at del array
array<sPersona, 3> arrPersona;

arrPerona.at(0).cedula = “123”;
arrPerona.at(0).nombre = “Juan”;

arrPerona.at(1).cedula = “224”;
arrPerona.at(1).nombre = “Manuel”;
 arrPerona.at(1).cedula = “325”;
arrPerona.at(1).nombre = “Arquimedes”;

Observación,
Se puede emplear la notación de corchetes para acceder a
los elementos del tipo la estructura, ver material de
arreglos enviado por correo previamente.

➢ Un vector donde el contenido sea del tipo estructura

vector<sPersona> vPersona;
sPersona persona1 = {“123”, “Juan”}; // Como dar valor inicial
a una instancia de una
estructura
sPersona persona2 = {“224”, “Manuel”};
sPersona persona3 = {“345”, “Arquimedes”};

vPersona.push_back(persona1);
vPersona.push_back(persona2);
vPersona.push_back(persona3);

vPersona.push_back( sPersona{“485”, “Maria”} );

Observaciones:
1. Al momento de crear una variable tipo una estructura, le podemos
asignar valores iniciales a la misma, ejemplo.
sPersona persona1 = {“123”, “Juan”};

En este ejemplo el valor

“123” se asigna al primer atributo valor (cedula)
“Juan” se asigna al segundo atributo miembro (nombre)

2. struct o clase <- Que diferencia existe?

En C++ es lo mismo un structura que una clase

❖ Diferencia entre structura y clase.

En struct los miembros son por defecto publico mientras
que en las clases los miembros son por defecto privados.

3. Existen tres niveles de visibilidad en los cuales se pueden agrupar

los miembros de una estructura, estos son:
1. public (visibilidad por defecto en las struct )
 Los miembros públicos solo pueden ser accedido
desde fuera de la estructura (Este el acceso que
poseen los ejemplos mostrado hasta este
momento).

2. private (visibilidad por defecto en las class -> clase)

Los miembros private solo pueden ser accedido
por los miembros de la clase (este caso lo veremos
mejor en el próximo ejemplo.

3. protected
Los miembros clasificados como protected o
protegidos pueden ser accedido por los miembros
de la clase o structura y por las clase o
estructuras derivadas, este nivel de visibilidad
guarda una estrecha relación con el concepto de
herencia (Uno de los pilares de la programación
orientada a objeto).

Este nivel de visibilidad lo trataran en la próxima

asignatura.

Ejemplo.
(a)
#include <iostream>
#include <string>

using namespace std;

struct sPersona
{
public:
string cedula;
string nombre;
};

int main()
{
sPersna persoa1 = {"001", "Juan"};

cout << persona1.cedula << endl;

cout << persona1.nombre << endl;

return 0;
}
(b)
#include <iostream>
#include <string>

using namespace std;

struct sPersona
{
private:
string cedula;
string nombre;
};

int main()
{
sPersna persoa1 = {"001", "Juan"};

cout << persona1.cedula << endl;

cout << persona1.nombre << endl;

return 0;
}

En este ejemplo cambiamos el nivel de visibilidad

de public para private, para este caso el
programa no compila, la razón de esto es que en
la función main se esta accediendo a los miembros
del objeto persona1 los cuales pertenecen al nivel
de visibilidad private.
(c)
#include <iostream>
#include <string>

using namespace std;

struct sPersona
{
private:
string cedula;
string nombre;

public:
void asignarCedula( string datoCedula )
{
cedula = datoCedula;
}

void asignarNombre( string datoNombre )

{
nombre = datoNombre;
}

void mostrarDatos()
{
cout << cedula << "-" << nombre;
}

};

int main()
{
sPersona persona1;

persona1.asignarCedula("123");
persona1.asignarNombre("Juan");

persona1.mostrarDatos();

return 0;
}

En este ejemplo no hay errores, notar que el ejemplo contiene dos

grupos de acceso, public y private, en el grupo privado colocamos las
variables miembros mientras que el grupo privado colocamos funciones
que permiten acceder a las variables miembros (esto se conoce como
encapsulamiento).

Nota;
Las funciones las veremos en la próxima unidad.

(d)
El archivo abmPersona.c++ programa ejemplo.
➢ Ejercicio
Crear programa en C++ que permita:
a. Registrar
b. Modificar
c. Eliminar
d. Listar

Un conjunto de producto

Un producto lo definen los siguientes atributos

Atributo Tipo de dato
Código Cadena ( string)
descripción Cadena ( string)
Precio Venta Flotante
Cantidad Mínima Entero
Cantidad Maxima Entero

Requisitos
1 Emplear <vector> para crear la lita de producto.
2 El código del producto debe tener 4 caracteres numéricos,
ejemplo: Códigos validos (0001, 1245), no validos (1,
00001, 45632, A45822).
3 Solo puede existir un producto con el mismo Código.
4 El solo se admiten descripción de producto con un mínimo
de 5 caracteres alfabéticos y un máximo de 40.
5 El Código del producto no puede ser modificado en
productos ya registrados