PDF de programación - Gestión Dinámica de Memoria - Estructuras de Datos

Ing Yamil Armando Cerquera Rojas



[email protected]

ESTRUCTURAS DE DATOS
Gestión Dinámica de Memoria
Funciones New – Malloc – Realloc – delete - free



Ing Yamil Armando Cerquera Rojas – [email protected]
Especialista en Sistemas Universidad Nacional
Docente Universidad Surcolombiana
Neiva - Huila


Contenido


Introducción______________________________________________________________ 2
El tipo de datos Puntero ___________________________________________________ 2
DEFINICIÓN: ______________________________________________________________ 3
Declaración de variables puntero ____________________________________________ 4
Asignación errónea: "Cannot assign..."________________________________________ 5
Operaciones con Punteros __________________________________________________ 6
Operadores específicos de punteros_______________________________________________ 7
Diferencia entre punteros y variables: _______________________________________ 8
Asignación de Punteros ____________________________________________________ 9
Comparación de Punteros _________________________________________________ 10
Asignación Dinámica de Memoria ___________________________________________ 10
Funciones de reserva de memoria: new______________________________________ 11
Función de liberación de memoria dinámica: delete ___________________________ 12
Ejemplo de asignación dinámica de memoria _________________________________ 13
Punteros a Estructuras ____________________________________________________ 13
Listas encadenadas o enlazadas ____________________________________________ 15
Operaciones básicas sobre listas enlazadas ___________________________________ 16
Otras clases de listas enlazadas ____________________________________________ 23
Ejercicios _______________________________________________________________ 27
Otras funciones de reserva de memoria de forma dinámica. ____________________ 30
Función de liberación de memoria dinámica: free() . __________________________ 33
Creación Dinámica de Arrays y Aritmética de Punteros. ________________________ 34


Universidad Surcolombiana



Pag 1 de 40

Ing Yamil Armando Cerquera Rojas



[email protected]

Introducción

En este tema se estudiarán las posibilidades que ofrece el Lenguaje C a la hora de
trabajar dinámicamente con la memoria dentro de los programas, esto es, reservar
y liberar bloques de memoria al momento de ejecutar un programa.

Además en este tema se introducirá el concepto de tipo abstracto de dato y la
forma de dividir un gran programa en otros más pequeños.

Los tipos de datos vistos hasta ahora, tanto los simples (Predefinidos por el lenguaje)
como los estructurados (Definidos por el programador), sirven para describir datos o
estructuras de datos cuyos tamaños y formas se conocen de antemano. Cuando se
declara una variable se reserva la memoria suficiente para contener la
información que debe almacenar. Esta memoria permanece asignada a la variable
hasta que termine la ejecución del programa (fin de la función main). Sin embargo,
hay programas cuyas estructuras de datos pueden variar de forma y tamaño durante la
existencia del mismo (En modo ejecución).

Las variables de todos los tipos de datos vistos son variables estáticas, en el sentido de
que se declaran en el programa, se designan por medio del identificador declarado
(variable), y se reserva para ellas un espacio en memoria en tiempo de compilación. El
contenido de la variable podrá cambiar durante la ejecución del programa, pero no el
tamaño de memoria reservado para determinada variable.

En ocasiones el tamaño de los objetos no se conoce hasta el momento de la
compilación. Por ejemplo, la longitud de una cadena de caracteres que introducirá el
usuario no se conoce hasta el tiempo de ejecución. El tamaño de un arreglo puede
depender de un parámetro cuyo valor se desconoce previo al momento de ejecución.
Ciertas estructuras de datos como listas enlazadas, pilas y colas utilizan memoria
dinámica.

C++, ofrece la posibilidad de crear o destruir variables en tiempo de ejecución del
programa, a medida que van siendo necesitadas durante la ejecución del mismo.
Puesto que estas variables no son declaradas en el programa, no tienen nombre y se
denominan variables anónimas. Si un lenguaje permite la creación de variables
anónimas, debe también proporcionar una forma de referirse a estas variables, de
modo que se les pueda asignar valores. Del mismo modo, debe proporcionar una forma
de acceder a estas. Para ello C++ proporciona el tipo Puntero.
El tipo de datos Puntero
El tipo puntero y las variables declaradas de tipo puntero se comportan de forma
diferente a las variables que se han estudiado en temas anteriores. Hasta ahora
cuando se declaraba una variable de un determinado tipo, dicha variable podía
contener directamente un valor de dicho tipo. Con el tipo puntero esto no es así.

Universidad Surcolombiana



Pag 2 de 40

Ing Yamil Armando Cerquera Rojas



[email protected]


Los punteros proporcionan la mayor parte de la potencia al C y C++, y marcan la
principal diferencia con otros lenguajes de programación.

Una buena comprensión y un buen dominio de los punteros pondrán en sus manos una
herramienta de gran potencia. Un conocimiento mediocre o incompleto te impedirá
desarrollar programas eficaces.

Por eso se le dedicará especial atención y mucho espacio a los punteros. Es muy
importante comprender bien cómo funcionan y cómo se usan.

Para entender qué es un puntero se da un repaso primero cómo se almacenan los
datos en un ordenador.

La memoria de un ordenador está compuesta por unidades básicas llamadas bits. Cada
bit sólo puede tomar dos valores, normalmente denominados alto y bajo, ó 1 y 0
(Estados lógicos). Pero trabajar con bits no es práctico, y por eso se agrupan.

Cada grupo de 8 bits forma un byte u octeto. En realidad el microprocesador, y por lo
tanto el programa, sólo puede manejar directamente bytes o grupos de dos o cuatro
bytes. Para acceder a los bits hay que acceder antes a los bytes. Y aquí se llega al
asunto, cada byte tiene una dirección, llamada normalmente dirección de memoria
(compuesta por un segmento y un desplazamiento).

La unidad de
la palabra, dependiendo del tipo de
microprocesador una palabra puede estar compuesta por dos, cuatro, ocho o dieciséis
bytes. Se hablará en estos casos de plataformas de 16, 32, 64 ó 128 bits. Se habla
indistintamente de direcciones de memoria, aunque las palabras sean de distinta
longitud. Cada dirección de memoria contiene siempre un byte (Una dirección de
memoria corresponde únicamente a un byte). Lo que sucederá cuando las palabras
sean de 32 bits es que se accede a posiciones de memoria que serán múltiplos de 4.

Todo esto sucede en el interior de la máquina, e imteresa más bien poco. Se puede
saber qué tipo de plataforma se usa averiguando el tamaño del tipo int, y para ello
hay que usar el operador "sizeof()", por ejemplo:

cout << "Plataforma de " << 8*sizeof(int) << " bits";
DEFINICIÓN:
Un puntero es un tipo especial de variable que contiene, ni más ni menos que, una
dirección de memoria. Por supuesto, a partir de esa dirección de memoria puede
haber cualquier tipo de objeto (o dato): un char, un int, un float, un array, una
estructura, una función u otro puntero. El programador será el responsables de decidir
ese contenido.


información básica es

Universidad Surcolombiana



Pag 3 de 40

Ing Yamil Armando Cerquera Rojas



[email protected]

En síntesis un puntero es una variable cuyo valor es la dirección de memoria de otra
variable. Esto quiere decir que un puntero se refiere indirectamente a un valor. Por
tanto, no hay que confundir una dirección de memoria con el contenido de esa
dirección de memoria:



Se hace una distinción entre la variable referencia (puntero) y la variable
referenciada por un puntero (anónima o apuntada).

Variable Referencia (Puntero): Es una variable estática, es decir se crea en tiempo de
compilación.

Variable Referenciada (Anónima): Es una variable dinámica creada en tiempo de
ejecución, que únicamente puede ser accedida a través de un puntero.

Una variable puntero no puede apuntar a cualquier variable anónima; debe apuntar a
variables anónimas de un determinado tipo. El tipo de la variable anónima vendrá
determinado por el tipo de la variable que la apunta. Este tipo debe ser incluido en la
especificación del tipo puntero.
Declaración de variables puntero
Un puntero, como cualquier variable u objeto, además de ser declarado (para
comenzar a existir) necesita ser inicializado (darle un valor de modo controlado), lo
cual se realiza mediante el operador de asignación ('='). Desde que el puntero es
declarado almacena un valor, el problema es que se trata de un valor aleatorio,
intentar operar con un puntero sin haberlo inicializado es una frecuente causa de
problemas.

Los punteros se declaran precediendo el identificador con el operador de indirección,
(*), que se leerá como "puntero a".

La forma general de declarar un tipo de datos puntero es la siguiente:

typedef <tipo> *<identificador>;

Donde tipo es el tipo base del puntero, que puede ser cualquier tipo válido e
identificador es el nombre del tipo de datos. Ejemplos de declaración de tipos de
datos punteros son los siguientes: