Estructuras de Datos

Introducción a la programación Orientada a Objetos

Augusto Gómez Eng.

augusto.gomez@correounivalle.edu.co

Escuela de Ingenierı́a de Sistemas y Computación

Universidad del Valle
 Contenido

1 Introducción

2 Punteros

3 Memoria Dinámica

4 Memoria Dinámica

5 Estructuras de Datos
Arreglos
String
Sentencia struct
Enumeraciones
 Introducción

Algunas veces no se pueden expresar un modelo usando una

variable con un tipo de dato (por ejemplo la lista de estudiantes
del curso). Para esto C++ (y los lenguajes en general
proporcionan estructuras para ordenar contenidos en la memoria
del computador. C++ proporciona dos tipos de estructuras:
Estáticas: Se define el tamaño de la estructura antes de
ejecutar y no se puede modificar en ejecución
Dinámicas: Se puede modificar el tamaño de la estructura
en tiempo de ejecución

Estructuras de Datos/ IPOO 1/26

 Punteros

Es una variable que contiene una dirección de memoria

Estructuras de Datos/ IPOO 2/26

 Definición y Acceso a Punteros

Para obtener la dirección de memoria de una variable se

usa el operador &
 
cout << & valor ; // 0 x62fe44
 
Para declarar una variable de tipo puntero se usa el
operador *. En la declaración también se define el tipo de
dato del puntero
 
int * puntero ;
 
Para obtener el valor almacenado en el puntero se usa
también el operador *
 
cout << * puntero ; // valor
 

Estructuras de Datos/ IPOO 3/26

 Modificando Valores de Punteros
Sobre un puntero se puede hacer la operación de
asignación simple para modificar la dirección de memoria
que va almacenar o para modificar el valor almacenado en
la posición de memoria
 
puntero = & direccion ; // modifica
direccion
* puntero = valor ; // modifica el valor
 
Si realiza una operación de suma o resta, el apuntador
mostrará las siguientes o las anteriores direcciones de
memoria
 
cout << puntero ; // 0 x62fe44
cout << puntero + 2; // 0 x62fe4c
 

Estructuras de Datos/ IPOO 4/26

 Memoria Dinámica

Cada vez que se ejecuta un programa, se carga primero en

la memoria del computador
En consecuencia, todos los elementos del programa
también se cargan en memoria
La memoria está organizada en series secuenciales de
espacios de memoria
Cada espacio se puede distinguir de los demás por su
dirección

Estructuras de Datos/ IPOO 5/26

 Memoria Estática

Estructuras de Datos/ IPOO 6/26

 Memoria Dinámica

El ámbito de una variable creada en memoria puede ser:

Estática: Se crea en el momento de definirse y se
destruyen al final del entorno {}
Dinámica: Puede ser definida por el usuario con el
operador new o new[] y se destruyen con el operador
delete o delete[]

Estructuras de Datos/ IPOO 7/26

 Memoria Dinámica

La memoria dinámica es un espacio de almacenamiento

que se puede solicitar en tiempo de ejecución
Además de solicitar espacios de almacenamiento, también
podemos liberarlos (en tiempo de ejecución) cuando
dejemos de necesitarlos

Estructuras de Datos/ IPOO 8/26

 Operadores Memoria Dinámica

new: Para crear un espacio de memoria para almacenar un

tipo de dato u objeto. La asignación se hace sobre un
puntero
new[]: para crear un espacio de memoria para almacenar
uno o más tipos de datos u objetos del mismo tipo. La
asignación se hace sobre un puntero
delete: Para liberar un espacio de memoria
delete[]: Para liberar un espacio de memoria de uno o
más tipos de datos u objetos

Estructuras de Datos/ IPOO 9/26

 Arreglos

Un conjunto de valores almacenados linealmente en posiciones

de memoria consecutiva. Un arreglo no es un tipo de dato sino
un agregado compuesto de valores con un tipo de dato. Cada
componente del arreglo tiene un ı́ndice que va desde 0 hasta el
tamaño del arreglo - 1)

Estructuras de Datos/ IPOO 10/26

 Declaración de Arreglos

Para declarar los arreglos se debe definir el tipo de dato de los

elementos que se van a almacenar y el tamaño del arreglo entre
llaves cuadradas. El tamaño debe ser un valor constante (literal
o mediante #define), no puede ser el nombre de una variable
 
tipo_de_dato nombre_arreglo [ tamano ];

// / Ejemplos
int id_productos [5]; // OK
int valores [5] = id_productos ; // Error
char integrantes [ valor ]; // Error
float eje_x [5+10]; // OK
 

Estructuras de Datos/ IPOO 11/26

 Inicialización y Acceso de Arreglos

Para inicializar arreglos se ponen los valores que irán

dentro de cada posición del arreglo entre llaves, si no se
pone tamaño en la declaración el tamaño será número de
los valores. No se puede declarar y luego inicializar en otra
linea
 
float eje_y [4] = {1.1 , 1.2 , 1.3 , 1.4};
float eje_x [] = {2.0 , 3.0 , 4.0 , 5.0};
 
Para acceder al valor almacenado en una posición del
arreglo pone el ı́ndice entre llaves cuadradas [ ] (los ı́ndices
comienzan desde 0). Al acceder se pueden modificar los
valores;
 
eje_y [0] = 1.0; // Cambia el valor
cout << eje_y [2]; // 1.3
 

Estructuras de Datos/ IPOO 12/26

 Relación entre Punteros y Arreglos

Se puede asignar a un puntero la variable del arreglo

directamente y en el puntero quedara almacenada la dirección
de memoria del primer elemento del arreglo. Podemos acceder a
cada uno de las direcciones del arreglo sumando valores al
puntero
 
int arreglo [3] = {1 , 2 , 3};
int * puntero = arreglo ; // puntero =
arreglo [0]
cout << * puntero ; // 1
cout << puntero [2]; // 3
cout << *( puntero + 2) ; // puntero [2]
 

Estructuras de Datos/ IPOO 13/26

 Arreglos Multidimensionales(I)

Se puede tener que un arreglo contenga como elementos dentro

de su estructura otros arreglos. Estos son arreglos
multidimensionales y las dimensión corresponde al número de
ı́ndices para acceder a un valor. No hay limite de las
dimensiones pero después de 3 se vuelve intratable

Estructuras de Datos/ IPOO 14/26

 Arreglos Multidimensionales(II)

La mejor forma de representar un arreglo es como una tabla

(dos dimensiones) o como un conjunto de tablas (3
dimensiones)

Estructuras de Datos/ IPOO 15/26

 Declaración e Inicialización de Arreglos
Multidimensionales

De acuerdo a la cantidad de dimensiones que tengan se

definen entre llaves cuadradas el tamaño de cada dimensión
 
int enteros [3][3]; // 2 D
float flotante [3][2][2]; // 3 D
 
Para inicializar se ponen entre llaves los valores de cada
arreglos respecto a su dimensión separadas con coma
 
int enteros [3][3] = {{1 , 2 , 3} ,{ 4 , 5 ,
6} , {7 , 8 , 9}};
float flotante [2][2][2] = {{{1 , 2} ,{3 ,
4}} , {{5 , 6} ,{7 , 8}} ,{ {9 , 10} , {11 ,
12}}};
 

Estructuras de Datos/ IPOO 16/26

 Acceso a Arreglos Multidimensionales

Para acceder al dato de un arreglo se pone el ı́ndice de la

columna seguido por el ı́ndice de la fila, cada uno entre llaves
cuadradas [ ]
 
int matriz [3][3] = {{1 , 2, 3} ,
{4 , 5, 6} ,
{7 , 8, 9}};
cout << matriz [1][1]; // 5
cout << matriz [1]; // {4 , 5 , 6}
 
Para calcular el tamaño de un arreglo se usa:
 
int size = sizeof ( id_arreglo ) / sizeof (
id_arreglo [0]) ;
 

Estructuras de Datos/ IPOO 17/26

 Iterando Arreglos
1D:
 
for ( int i = 0; i < size ; i ++)
id_arreglo [ i ];
 
2D:
 
for ( int fila = 0; fila < num_filas ; fila ++)
for ( int columna = 0; columna <
num_columnas ; columna ++)
id_arreglo [ fila ][ columna ];
 
3D:
 
for ( int x = 0; x < num_tablas ; x ++)
for ( int y = 0; y < num_filas ; y ++)
for ( int z = 0; z < num_columnas ; z ++)
id_arreglo [ x ][ y ][ z ];
 

Estructuras de Datos/ IPOO 18/26

 Cadenas de Caracteres (string)

La clase string trabaja datos como cadenas de caracteres. Se

puede inicializar de las siguientes formas
 
string s1 ; // OK - vacio
string s2 = s1 ; // OK - copia
string s3 = " hiya " ; // OK - copia literal
string s4 (10 , ’c ’) ; // OK - 10 veces ’c ’
string 25( " hola " ) ; // OK
 

Estructuras de Datos/ IPOO 19/26

 Operaciones con string

Sintaxis Resultado
id string.empty() true si esta vacio, false si no lo está
id string.size() retorna el número de caracteres
id string[n] retorna el n-avo carácter del string
string1 + string2 concatena el string1 y el string2
string1 += string2 concatena el string1 y el string2
string1 == string2 string1 y string2 son iguales
string1 != string2 string1 y string2 son diferentes

Estructuras de Datos/ IPOO 20/26

 Tratando con caracteres

Se debe incluir en la cabecera la libreria <cctype> que incluye

varias funciones
Funciones Valor de Retorno
isalnum(c) true si c es alfanumérico
isalpha(c) true si c es alfabetico
isblank(c) true si c es un espacio o tabulación
isdigit(c) true si c es un digito (0–9)
islower(c) true si c es minúscula
ispunct(c) true si c es un signo de puntuación
isspace(c) true si c es un espacio en blanco estándar
isupper(c) true si c es mayúscula
tolower(c) retorna c en minúscula
toupper(c) retorna c en mayúscula

Estructuras de Datos/ IPOO 21/26

 Sentencia struct

Es un tipo definido por el usuario que sirve para definir

propiedades basadas en tipos de datos. Dentro de la sentencia
struct podemos agrupar varios datos de diferentes tipos
 
struct identificador {
tipo_dato miembro1 ;
tipo_dato miembro2 ;
.
.
.
tipo_dato miembroN ;
} declaracion _o b j et o s ( opcional ) ;
 

Estructuras de Datos/ IPOO 22/26

 Declaración e Inicialización de
Estructuras
Una vez definida una estructura podemos declarar variables de
tipo struct. Para inicializar ponemos los valores que toma
cada miembro de la estructura separados por coma (,)
 
struct Estudiante {
string nombre ;
int codigo ;
float nota ;
} estudiante1 ; // declaracion

Estudiante estudiante2 ; // declaracion

// Declarando e Inicializando
Estudiante estudiante3 { " Andres " , 16 , 3.6};
Estudiante estudiante4 = { " Ivan " , 2 , 4.2};
 

Estructuras de Datos/ IPOO 23/26

 Acceso a Miembros de una Estructura

Usamos el identificador de la variable de tipo estructura seguido

de punto (.) y luego del miembro que se desea acceder (Se
puede leer y escribir el miembro)
 
estudiante1 . codigo = 160578;
int codigo2 = estudiante1 . codigo ;

cout << estudiante1 . nombre ;

 

Estructuras de Datos/ IPOO 24/26

 Enumeraciones

Es un tipo definido por el usuario que consta de un conjunto de

constantes enteras asociadas a un nombre. Cada componente
del enumeración corresponde a tener (const variable = entero)
 
enum identific ad or _e nu m {
identificador1 ,
.
identificadorN
};
enum identific ad or _e nu m {
identificador1 = 0 ,
.
identificadorN = N
};
 

Estructuras de Datos/ IPOO 25/26

 Declarando y Usando Enumeraciones

 
enum Colores { rojo , verde , azul , amarillo };

enum Figuras { circulo = 2 , cuadrado = 3 ,

rectangulo = 6 };

enum Error { sobrecarga = 55 , division_cero ,

memoria , disco };

int error = 56;

if ( error == division_cero )
cout << " Intenta hacer division entre 0 " ;
 

Estructuras de Datos/ IPOO 26/26