Está en la página 1de 22

UNIVERSIDAD TECNOLÓGICA DE

PANAMÁ

FACULTAD DE INGENIERÍA DE
SISTEMAS COMPUTACIONALES

HERRAMIENTA DE PROGRAMACION APLICADA I

ASIGNACIÓN DINÁMICA DE MEMORIA y ARCHIVOS DE DATOS.

GRUPO: 1IL-115

PROFESORA
Dra. ADDYS DE LAM

INTEGRANTES
SANCHEZ ERNESTO 9-743-681
GUAINORA ANA 8-947-2254
NAVARRETE NAZARETH 8-879-2126

GRUPO DE TRABAJO NO. 4

FECHA
MATES 6 DE NOVIEMBE DEL 2018
INTRODUCCION ....................................................................................................................................... 3
1. OBJETIVOS. ....................................................................................................................................... 4
2. ASIGNACIÓN DINÁMICA DE MEMORIA. .................................................................................... 4
2.1. Definición ...................................................................................................................................... 4
2.2. SISTEMA DE ASIGNACIÓN DINÁMICA PARA TURBO C. ................................................. 5
2.2.1. Gráfico y explicación FALTA ............................................................................................... 5
2.3. Obtención de memoria en tiempo de ejecución ............................................................................ 7
2.3.1. Función malloc ....................................................................................................................... 7
2.3.2. Función free ........................................................................................................................... 7
2.3.3. Error en la asignación de memoria. ....................................................................................... 8
2.3.4. Función calloc ........................................................................................................................ 9
2.3.5. Función realloc ....................................................................................................................... 9
2.3.6. Ejemplo para cada función ................................................................................................... 10
2.3.7. Programa ejemplo. ............................................................................................................... 11
3. ARCHIVOS DE DATOS................................................................................................................... 12
3.1. Definición y uso. ......................................................................................................................... 12
3.2. Archivos de textos y acceso secuencial. ...................................................................................... 12
3.3. Apertura y cierre. ......................................................................................................................... 13
3.4. Lectura y escritura de cadenas de caracteres en archivos de texto. ............................................. 14
3.5. Archivos de acceso directo .......................................................................................................... 15
3.6. Leer los datos............................................................................................................................... 16
3.7. Añadir datos ................................................................................................................................ 17
3.8. Escribir los datos ......................................................................................................................... 18
3.9. Programas Ejemplos .................................................................................................................... 18
4. Conclusión. ........................................................................................................................................ 19
5. Referencias. ........................................................................................................................................ 20
INTRODUCCION

Los tipos de datos, tanto simples como estructurados, vistos hasta ahora en los temas anteriores ), sirven
para describir datos o estructuras de datos cuyos tamaños y formas se conocen de antemano. Sin embargo,
en muchos programas es necesario que las estructuras de datos estén diseñadas de manera que su tamaño
y forma varíe a lo largo de la ejecución de aquellos. Con esto se consigue, fundamentalmente, que estos
programas funcionen de manera más eficiente y con un aprovechamiento óptimo de los recursos de
almacenamiento en memoria principal.

Las variables de todos los tipos de datos vistos hasta el momento son denominadas variables estáticas, en
el sentido en que se declaran en el programa, se designan por medio del identificador declarado, y se
reserva para ellas un espacio en memoria en tiempo de compilación de los programas. El contenido de la
variable estática puede cambiar durante la ejecución del programa o subprograma donde está declarada,
pero no así el tamaño en memoria reservada para ella. Esto significa que la dimensión de las estructuras
de datos a las que se refieren estas variables debe estar determinada en tiempo de compilación, lo que
puede suponer una gestión ineficiente de la memoria, en el sentido de que puede implicar el desperdicio
(por sobredimensionamiento) o la insuficiencia (por infra dimensionamiento) de memoria.

Sin embargo, son muchos los lenguajes de programación que ofrecen la posibilidad de crear y destruir
variables en tiempo de ejecución, de manera dinámica, a medida que van siendo necesitadas durante la
ejecución del programa. Puesto que estas variables no son declaradas explícitamente en el programa y no
tienen identificador (nombre) asignado, se denominan variables anónimas.

En la mayor parte de los programas se quiere almacenar información que no desaparezca al finalizar la
ejecución de estos. Esto es lo que diferencia el almacenamiento de datos en ficheros al almacenamiento
de datos en estructuras, vectores, etc…

Antiguamente el C trataba bajo Unix los ficheros como una sucesión de octetos (grupos de 8 bits)
pudiendo accederse a cada uno de forma individual. En posteriores generalizaciones del C en sistemas
operativos diferentes se modificó la forma de tratar y usar los ficheros por parte del C, creándose una
serie de librerías para facilitar su manipulación.
Este es el caso de la librería stdio.h (acrónimo de standard input/output), que define estructuras de tipo
fichero y un conjunto de funciones que nos facilitarán el trabajo con los ficheros.
1. OBJETIVOS.
 Establecer de forma clara y concisa la definición, características, acerca de la administración
dinámica de memoria.
 Aprender las diferentes funciones que se utilizan durante el manejo de memoria dinámica.
 Utilizar memoria dinámica cuando el almacén de memoria principal sea muy grande.
 Comprender el uso de los archivos.
 Declaración E Inicialización de variable tipo archivo (file).
 Aprender la manera adecuada tanto de la creación o escritura, como la lectura de los archivos.
 Conocer la sintaxis de las diferentes funciones en la asignación de memoria y creaciones de
archivos.
 Conservar los valores de nuestras variables tras finalizar la ejecución de algún programa
mediante el uso de archivos.
 Usar apropiadamente los operadores de reserva y liberación de memoria dinámica.

2. ASIGNACIÓN DINÁMICA DE MEMORIA.


2.1. Definición
Existen dos métodos para guardar información de un programa en la memoria del computador.

 El primero, es la que utiliza para las variables globales y locales. Con las globales se asigna
un área de almacenamiento fijo durante toda la ejecución del programa en el espacio
(variables globales), mientras que las locales son almacenadas en el espacio (pila).
 El segundo, consiste en asignar el espacio de memoria disponible. Localizado entre el cuerpo
del programa, incluyendo el espacio de las variables locales y el área de pila como se muestra
a continuación.

Área del programa

Variables globales
heap
Memoria libre para asignación Dirección de crecimiento

Pila (aquí van las locales)


Crece hacia abajo Dirección de crecimiento

La pila crece hacia abajo a medida que el programa la utiliza. La computadora toma la memoria
para asignarla bajo el segundo método desde la zona de memoria libre, empezando justo debajo
de las variables globales y creciendo hacia la pila.
La asignación dinámica de memoria consiste en asignar la cantidad de memoria necesaria para
almacenar un objeto durante la ejecución del programa, en vez de hacerlo en el momento de
compilación de este (programa).

2.2. SISTEMA DE ASIGNACIÓN DINÁMICA PARA TURBO C.


2.2.1. Gráfico y explicación
2.3. Obtención de memoria en tiempo de ejecución
2.3.1. Función malloc

malloc( ): Esta localiza un área de memoria disponible en la zona de memoria libre para
asignación que satisfaga el pedido realizado.

Cuando se usa la función malloc() la memoria no es inicializada a cero o borrada.

Formato:
p = malloc (t);

p: puntero al primer byte del bloque de la memoria que se asignará, en caso


Contrario devuelve un puntero NULL (contiene 0).
t: cantidad, en bytes que se solicitan.

2.3.2. Función free


free ( ): Devuelve al sistema la memoria asignada para su posterior reutilización. Libera un
bloque asignado por las funciones malloc( ), calloc( ), o realloc( ).

Formato:

free (p);
p: debe ser un puntero válido, ya que se podría destruir el sistema de
Administración de memoria libre.

2.3.3. Error en la asignación de memoria.

Una de las anomalías más comunes cuando se gestiona la memoria de forma explícita es lo que se
conoce como “fuga de memoria”. Esta situación ocurre cuando un programa obtiene memoria
dinámica, y el valor del puntero que devuelve el sistema, por error, se pierde. En tal caso, ya no es
posible invocar a la función free con ese puntero, y la porción de memoria se queda reservada por
lo que resta de ejecución. Como ejemplo de fuga de memoria analicemos el siguiente fragmento de
código.

char *string;
string = (char *)malloc(100);
string = NULL;

La primera línea declara un puntero a carácter. En la segunda se reserva un espacio de 100 bytes. El
gestor de memoria devuelve un puntero al comienzo de ese bloque y se almacena en la variable
string. En ese momento, la dirección de ese bloque no está almacenada en ningún otro sitio. La
línea siguiente asigna el valor NULL al mismo puntero. ¿Qué ha sucedido con la dirección de
memoria de la porción que se acaba de reservar? Se ha perdido y no hay forma alguna de
recuperarla, porque string era la única copia de ese valor. Como consecuencia, la porción de
memoria reservada seguirá marcada como ocupada por el resto de ejecución del programa. La
memoria se ha fugado.

La llamada a malloc
podría "fallar" si por algún motivo el sistema operativo no puede darle la cantidad de memoria
especificada a nuestro programa. Cuando este sucede malloc retorna NULL.
Entonces, en teoría deberíamos siempre realizar este checkeo:

int *puntero = malloc(4);


if (puntero == NULL) {
fprintf(stderr, "La aplicacion no pudo reservar memoria y se
va a cerrar!\n");
exit(EXIT_FAILURE);}

NOTA:
1. Es muy importante que antes de utilizar una variable dinámica, ésta tenga memoria reservada, si no los
resultados pueden ser impredecibles.

2. También es muy importante que toda memoria reservada sea posteriormente liberada.

2.3.4. Función calloc

calloc( ): Esta función asigna espacio de memoria, pero cada espacio es inicializado en cero
(o). El espacio requerido debe ser inferior a 64k.

Formato:

p=calloc(n, t);

p: puntero al primer byte de la región de la memoria que se asignará, en caso


Contrario devuelve un puntero NULL.

n: cantidad de elementos
t: cantidad, en bytes que se solicitan.

2.3.5. Función realloc

realloc( ): Cambia el tamaño de un bloque de memoria previamente asignado.


Puede devolvernos la zona de memoria solicitada en otra posición o la misma.
Se puede agrandar o achicar el bloque.
Formato:
p=realloc(p,t);

p: es un puntero que apunta al comienzo del bloque.


Si p es NULL, este se comporta igual que el malloc ( ).
Si p no es NULL, entonces tiene que ser un puntero devuelto por las funciones
malloc( ), calloc( ) o por la propia función realloc( ). El bloque ha podido,
incluso, ser liberado por la función free().

t: tamaño nuevo solicitado del bloque en bytes. El contenido del bloque no


cambia en el espacio conservado.
Si originalmente se pide 3 y luego hago un realloc de 5 entonces se dan 5
celdas más, quedando 8 en total.

2.3.6. Ejemplo para cada función

malloc( ):
Ejemplo:
int *p;
p=(int *) malloc (sizeof (int)); // pide 2 bytes
Ejemplo:

int *p;
p=(int *) malloc (n * sizeof (int)); //si no se especifica el tipo de dato asume 1 byte
//es para char

Cantidad de Multiplica Para indicar el número de bytes asociado

elementos con una estructura de datos

estructura
Cantidad de bytes = cantidad * 2 bytes para un entero

Free( ):
Ejemplo:
int main(){
while(1) {
int* ptr = (int*)malloc(1000*sizeof(int));
// operaciones sobre ptr
free(ptr); }}

calloc( ):
Ejemplo:

int *p;

p=(int *) calloc (40,sizeof(int));

realloc( ):
Ejemplo:
int *p;
p= (int *) malloc (3 * sizeof (int));
p= (int *) realloc (p, 5 * sizeof (int));

2.3.7. Programa ejemplo.


#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
main()
{
int *x, mayor, i, p;
x = (int *)malloc(5 * sizeof(int)); /* solicitud de celdas de memoria */
if (x != NULL)
{ //carga las celdas de memoria
printf("\n\n");
for (i = 0; i < 5; i++)
{
printf("Entre el valor de la celda %x ", x + i);
scanf("%i", x + i);
}
mayor = x[0];
for (i = 0; i < 5; i++)
if (x[i] > mayor)
{
mayor = x[i];
p = i;
}
printf("\nEl valor mayor es : %i", mayor);
printf("\nEsta en la posición : %i", p);
printf("\nEsta en la dirección : %x", x + p);
}
else
printf("\nno hay espacio en la memoria dinamica");
free(x);
getch();
}
3. ARCHIVOS DE DATOS.
3.1. Definición y uso.
Un archivo es un conjunto de datos estructurados en una colección de entidades elementales o
básicas denominadas registros que son de igual tipo y constan a su vez de diferentes entidades de
nivel más bajos denominadas campos.

Se pueden usar para:

Un archivo de texto es una secuencia de caracteres organizadas en líneas terminadas por un carácter
de nueva línea. En estos archivos se pueden almacenar canciones, fuentes de programas, base de
datos simples, etc. Los archivos de texto se caracterizan por ser planos, es decir, todas las letras
tienen el mismo formato y no hay palabras subrayadas, en negrita, o letras de distinto tamaño o
ancho.

Un archivo binario es una secuencia de bytes que tienen una correspondencia uno a uno con un
dispositivo externo. Así que no tendrá lugar ninguna traducción de caracteres. Además, el número de
bytes escritos (leídos) será el mismo que los encontrados en el dispositivo externo. Ejemplos de estos
archivos son Fotografías, imágenes, texto con formatos, archivos ejecutables (aplicaciones), etc.

3.2. Archivos de textos y acceso secuencial.

En estos archivos, la información sólo puede leerse y escribirse empezando desde el principio del
archivo.

Los archivos secuenciales tienen algunas características que hay que tener en cuenta:

1. La escritura de nuevos datos siempre se hace al final del archivo.


2. Para leer una zona concreta del archivo hay que avanzar siempre, si la zona está antes de la
zona actual de lectura, será necesario "rebobinar" el archivo.
3. Los ficheros sólo se pueden abrir para lectura o para escritura, nunca de los dos modos a la
vez.

Esto es en teoría, por supuesto, en realidad C no distingue si los archivos que usamos son
secuenciales o no, es el tratamiento que hagamos de ellos lo que los clasifica como de uno u otro
tipo.

Pero hay archivos que se comportan siempre como secuenciales, por ejemplo los ficheros de entrada
y salida estándar: stdin, stdout, stderr y stdaux.
Tomemos el caso de stdin, que suele ser el teclado. Nuestro programa sólo podrá abrir ese fichero
como de lectura, y sólo podrá leer los caracteres a medida que estén disponibles, y en el mismo orden
en que fueron tecleados.

Lo mismo se aplica para stdout y stderr, que es la pantalla, en estos casos sólo se pueden usar para
escritura, y el orden en que se muestra la información es el mismo en que se envía.

Un caso especial es stdaux, que suele ser el puerto serie. También es un archivo secuencial, con
respecto al modo en que se leen y escriben los datos. Sin embargo se un fichero de entrada y salida.

modo significado
“r” Abre un archivo para lectura de archivo de textos (el archivo tiene que
existir)
“w” Crea un archivo de escritura de archivo de textos. Si el archivo ya existe se
borra el contenido que posee.
“a” Abre un archivo para adición de datos de archivo de textos
“rb” Abre un archivo para lectura de archivos binarios (el archivo tiene que
existir)
“wb” Crea un archivo para escritura de archivos binarios (si ya existe, se descarta
el contenido)
“ab” Abre un archivo para añadir datos en archivos binarios
“r+” Abre un archivo de texto para lectura/escritura en archivos de texto. El
archivo tiene que existir
“w+” Crea un archivo de texto para lectura/escritura en archivos de texto. Si el
archivo tenía datos, estos se descartan en la apertura.
“a+” Crea o abre un archivo de texto para lectura/escritura. Los datos se
escriben al final.
“r+b” Abre un archivo binario para lectura/escritura en archivos de texto
“w+b” Crea un archivo binario para lectura/escritura en archivos de texto. Si el
archivo tiene datos, éstos se pierden.
“a+b” Crea o abre un archivo binario para lectura/escritura. La escritura se hace
al final de el archivo.
3.3. Apertura y cierre.
a. Apertura

La apertura de los archivos se realiza con la función fopen. Esta función devuelve un
puntero de tipo FILE al archivo que se desea abrir. El prototipo de la función es:

FILE *fopen(const char *nombreArchivo, const char *modo)

nombreArchivo es una cadena que contiene la ruta hacia el archivo que se desea abrir.
modo es otra cadena cuyo contenido puede ser:
Un archivo se puede abrir en modo texto o en modo binario. En modo texto se leen o
escriben caracteres, en modo binario se leen y escriben cualquier otro tipo de datos.
La función fopen devuelve un puntero de tipo FILE al archivo que se está abriendo.
En caso de que esta apertura falle, devuelve el valor NULL (puntero nulo). El fallo se
puede producir porque el archivo no exista (sólo en los modos r), porque la ruta al archivo
no sea correcta, porque no haya permisos suficientes para la apertura, porque haya un
problema en el sistema,….

b. Cierre

La función fclose es la encargada de cerrar un archivo previamente abierto. Su prototipo


es:

int fclose(FILE *pArchivo);

pArchivo es el puntero que señala al archivo que se desea cerrar. Si devuelve el valor cero,
significa que el cierre ha sido correcto, en otro caso se devuelve un número distinto de
cero.

3.4. Lectura y escritura de cadenas de caracteres en archivos de texto.

función getc
Esta función sirve para leer caracteres de un archivo de texto. Los caracteres se van
leyendo secuencialmente hasta llegar al final. Su prototipo es:

int getc(FILE *pArchivo);

Esta función devuelve una constante numérica llamada EOF (definida también en el
archivo (stdio.h) cuando ya se ha alcanzado el final del archivo. En otro caso devuelve el
siguiente carácter del archivo.

Ejemplo:

#include <stdio.h>
#include <conio.h>

int main(){
FILE *archivo;
char c=0;
archivo=fopen("c:\\prueba.txt","r+");
if(archivo!=NULL) { /* Apertura correcta */
while(c!=EOF){ /* Se lee hasta llegar al final */
c=fgetc(archivo);
putchar(c);
}
fclose(archivo);
}
else{
printf("Error");
}
getch();
}

función fputc

Es la función que permite escribir caracteres en un archivo de texto. Prototipo:

int putc(int carácter, FILE *pArchivo);

Escribe el carácter indicado en el archivo asociado al puntero que se indique. Si esta


función tiene éxito (es decir, realmente escribe el carácter) devuelve el carácter escrito, en
otro caso devuelve EOF.

3.5. Archivos de acceso directo


Los archivos de acceso directo son aquellos en los que se puede acceder a cualquier parte
del archivo sin pasar por las anteriores. Hasta ahora todas las funciones de proceso de
archivos vistas han trabajado con los mismos de manera secuencial.
En los archivos de acceso directo se entiende que hay un indicador de posición en los
archivos que señala el dato que se desea leer o escribir. Las funciones fread o fwrite
vistas anteriormente (o las señalas para leer textos) mueven el indicador de posición cada
vez que se usan.
El acceso directo se consigue si se modifica ese indicador de posición hacia la posición
deseada. Eso lo realiza la función fseek cuyo prototipo es:

int fseek(FILE * pArchivo, long bytes, int origen)

Esta función coloca el cursor en la posición marcada por el origen desplazándose desde allí
el número de bytes indicado por el segundo parámetro (que puede ser negativo). Para el
parámetro origen se pueden utilizar estas constantes (definidas en stdio.h):
SEEK_SET. Indica el principio del archivo.
SEEK_CUR. Posición actual.
SEEK_END. Indica el final del archivo.

La función devuelve cero si no hubo problemas al recolocar el indicador de posición del


archivo. En caso contrario devuelve un valor distinto de cero:
Por ejemplo:
typedef struct {
char nombre[25];
int edad;
}Persona;

int main(){
Persona aux;
FILE *pArchivo;
pArchivo=fopen("C:\\datos.dat","rb");
if(pArchivo!=NULL){
fseek(pArchivo,3*sizeof(Persona),SEEK_SET);
fread(&aux,sizeof(Persona),1,pArchivo);
printf(“%s, %d años”,aux.nombre,aux.edad);
fclose(pArchivo);
}
}

3.6. Leer los datos


función fgets
Se trata de una función que permite leer textos de un archivo de texto. Su prototipo es:

char *fgets(char *texto, int longitud, FILE *pArchivo)

Esta función lee una cadena de caracteres del archivo asociado al puntero de archivos
pArchivo y la almacena en el puntero texto. Lee la cadena hasta que llegue un salto de
línea, o hasta que se supere la longitud indicada. La función devuelve un puntero
señalando al texto leído o un puntero nulo (NULL) si la operación provoca un error.
Ejemplo (lectura de un archivo de texto):

#include <stdio.h>
#include <conio.h>

int main(){
FILE *archivo;
char texto[2000];
archivo=fopen("c:\\prueba2.txt","r");
if(archivo!=NULL) {
fgets(texto,2000,archivo);
while(!feof(archivo)){
puts(texto);
fgets(texto,2000,archivo);
}
fclose(archivo);
}
else{
printf("Error en la apertura");
}
}

3.7. Añadir datos

función fprintf
Se trata de la función equivalente a la función printf sólo que esta permite la escritura en
archivos de texto. El formato es el mismo que el de la función printf, sólo que se añade un
parámetro al principio que es el puntero al archivo en el que se desea escribir.
La ventaja de esta instrucción es que aporta una gran versatilidad a la hora de escribir
en un archivo de texto.
Ejemplo. Imaginemos que deseamos almacenar en un archivo los datos de nuestros
empleados, por ejemplo su número de empleado (un entero), su nombre (una cadena de
texto) y su sueldo (un valor decimal). Entonces habrá que leer esos tres datos por
separado, pero al escribir lo haremos en el mismo archivo separándolos por una marca de
tabulación. El código sería:
#include <stdio.h>

int main(){
int n=1; /*Número del empleado*/
char nombre[80];
double salario;
FILE *pArchivo;
pArchivo=fopen("c:\\prueba3.txt","w");
if(pArchivo!=NULL){
do{
printf("Introduzca el número de empleado: ");
scanf("%d",&n);
/*Solo seguimos si n es positivo, en otro caso
entenderemos que la lista ha terminado */
if(n>0){
printf("Introduzca el nombre del empleado: ");
scanf("%s",nombre);
printf("Introduzca el salario del empleado: ");
scanf("%lf",&salario);
fprintf(pArchivo,"%d\t%s\t%lf\n",
n,nombre,salario);
}
}while(n>0);
fclose(pArchivo);
}
}
3.8. Escribir los datos
función fputs
Es equivalente a la anterior, sólo que ahora sirve para escribir strings dentro del un
archivo de texto. Prototipo:

int fputs(const char texto, FILE *pArchivo)

Escribe el texto en el archivo indicado. Además al final del texto colocará el carácter del
salto de línea (al igual que hace la función puts). En el caso de que ocurra un error,
devuelve EOF.

3.9. Programas Ejemplos

/*
Crear un programa que pida al usuario pares de números enteros y escriba su suma
(con el
formato "20 + 3 = 23") en pantalla y en un fichero llamado "sumas.txt", que se
encontrará en un
subdirectorio llamado "resultados". Cada vez que se ejecute el programa, deberá
añadir los nuevos
resultados a continuación de los resultados de las ejecuciones anteriores.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
FILE *resultados;
int numero1 = 0, numero2 = 0, suma = 0;

resultados = fopen("sumas.txt", "a+");


if (resultados == NULL)
printf("No se pudo abrir el archivo.\n");
else
{
do
{
fscanf(resultados, "%d + %d = %d", &numero1, &numero2, &suma);
if (feof(resultados))
break;
printf("%d + %d = %d\n", numero1, numero2, suma);
} while (!feof(resultados));

printf("Escriba dos numeros.\n\"000\" para salir.\n");


do
{
printf("Primer numero: ");
scanf("%d", &numero1);
if (numero1 == 0)
exit(1);
printf("Segundo numero: ");
scanf("%d", &numero2);
suma = numero1 + numero2;
printf("%d + %d = %d\n", numero1, numero2, suma);
fprintf(resultados, "%d + %d = %d\n", numero1, numero2, suma);
} while (numero1 != 0);
fclose(resultados);
}
return 0;
}

4. Conclusión.
ASIGNACION DINAMICA DE MEMORIA

Como hemos visto los punteros son necesario para ejecutar un comando y realizar un programa ya que
son puntos de inicio y clave que dan a corregir fallas para hacer funcionar el dicho programa.

La memoria reservada de forma dinámica suele estar alojada en el heap o almacenamiento libre, y la
memoria estática en el stack o pila. La pila generalmente es una zona muy limitada. El heap, en cambio,
en principio podría estar limitado por la cantidad de memoria disponible durante la ejecución del
programa y el máximo de memoria que el sistema operativo permita direccionar a un proceso. En
cualquier caso, lo único que se puede asumir es que muy probablemente dispondremos de menor espacio
en la pila que en el heap.

La memoria dinámica se puede ir incrementando durante la ejecución del programa. Esto permite, por
ejemplo, trabajar con arreglos dinámicos. Aunque en C, a partir del estándar C99 se permite la creación
de arreglos cuyo tamaño se determina en tiempo de ejecución, no todos los compiladores implementan
este estándar. Además, se sigue teniendo la limitante de que su tamaño no puede cambiar una vez que se
especifica, cosa que sí se puede lograr asignando la memoria de forma dinámica.

Pese a todo lo bueno que se puede ofrecer utilizando las asignaciones dinámicas de memoria hay que
decir que se es más difícil de manejar. La memoria estática tiene una duración fija, que se reserva y
libera de forma automática. En contraste, la memoria dinámica se reserva de forma explícita y continúa
existiendo hasta que sea liberada, generalmente por parte del programador.

Además, puede afectar el rendimiento. Puesto que con la memoria estática el tamaño de las variables se
conecta en tiempo de compilación, esta información está incluida en el código objeto generado, por lo
cual el proceso es muy eficiente. Cuando se reserva memoria de manera dinámica, se tienen que llevar a
cabo varias tareas, como buscar un bloque de memoria libre y almacenar la posición y tamaño de la
memoria asignada, de manera que pueda ser liberada más adelante. Todo esto representa una carga
adicional, aunque esto depende de la implementación y hay técnicas para reducir su impacto.

ARCHIVOS DE DATOS

Es de suma importancia conocer el manejo que da lenguaje brinda a sus archivos, además de cuáles son
los diferentes tipos de archivos que implementan los lenguajes y cuáles son los más utilizados
actualmente

Si deseamos realizar programas donde la información que el usuario ingrese deba ser recuperada
y procesada frecuentemente, una buena estructura de archivos nos permitirá lograr ese cometido, pues
en ella radica el éxito del procesamiento de dicha información.

Al trabajar con archivos es preciso recordar sus tipos, formas de creación (lectura/escritura), pero sobre
todo debemos recordar que siempre que terminemos de trabajar con un archivo debemos cerrarlo.

Aunque existe una gran diversidad de aplicaciones que se pueden desarrollar con manejo de archivos que
pueden ser sumamente completas y complejas, esta investigación presenta, de una forma sencilla y
comprensible, los aspectos básicos de programación de archivos usando lenguaje C. De tal forma, que no
presenta lógica abrumadora de control de detalles, sino la base fundamental del material es entender y
utilizar las funciones básicas de manejo de archivos en este lenguaje para posteriormente usarlas en
cursos posteriores.

5. Referencias.

Titulo Memoria dinámica (programación)


Sitio web Es.wikipedia.org
URL: https://es.wikipedia.org/wiki/Memoria_din%C3%A1mica_(programaci%C3%B3n)

Titulo Programación en C/Manejo dinámico de memoria - Wikilibros


Sitio
Es.wikibooks.org
web
URL: https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_din%C3%A1mico_de_memoria

Titulo Asignación dinámica de memoria y administración de memoria c


Sitio web prezi.com
https://prezi.com/hoguxp55jpcl/asignacion-dinamica-de-memoria-y-administracion-de-
URL:
memoria-c/

Sitio web Informatica.uv.es


URL: http://informatica.uv.es/iiguia/AED/oldwww/2004_05/AED.Tema.08.pdf