Texto Parte II PDF

Metodología de la Programación
INDICE GENERAL
PUNTEROS Y ESTRUCTURAS DINÁMICAS DE DATOS ..........................................................................3

1.1. OPERADORES PARA EL MANEJO DE PUNTEROS. .........................................................................3
1.1.1. OPERADOR DE DIRECCION ‘&’. .................................................................................................3
1.1.2 OPERADOR DE INDIRECCION O CONTENIDO ‘*’. .......................................................................4
1.2. DECLARACIÓN DE PUNTEROS. .....................................................................................................4
1.2.1. ALMACENAMIENTO EN UNA VARIABLE PUNTERO. ..................................................................5
1.3. OPERACIONES CON PUNTEROS. ..................................................................................................6
1.3.1. ASIGNACION. ............................................................................................................................7
1.3.2. COMPARACION. .......................................................................................................................7
1.3.3. ARITMETICA CON PUNTEROS. ..................................................................................................8
1.4. PUNTEROS Y ARREGLOS. ...........................................................................................................10
1.4.1. PUNTERO A CADENA DE CARACTERES. ..................................................................................12
1.4.2. PUNTEROS A ESTRUCTURAS. ..................................................................................................14
1.5. ESTRUCTURAS DINÁMICAS DE DATOS. LISTAS SIMPLES. ...........................................................16
1.5.1. OPERACIONES BASICAS EN UNA LISTA SIMPLE. .....................................................................17
ARCHIVOS .........................................................................................................................................22
2.1. DEFINICION. ..............................................................................................................................22
2.2. PROPIEDADES DE UN ARCHIVO. ................................................................................................22
2.3. ORGANIZACIÓN DE UN ARCHIVO. .............................................................................................24
2.3.1. ORGANIZACIÓN SECUENCIAL. ................................................................................................24
2.3.2. ORGANIZACIÓN DIRECTA/RANDOMICA O ALEATORIA. ..........................................................25
2.4. USO DE ARCHIVOS. ....................................................................................................................25
2.5. ENTRADA Y SALIDA EN ARCHIVOS. ............................................................................................26
2.6. PROCESAMIENTO DE ARCHIVOS EN EL DISCO. ..........................................................................26
2.6.1. ABRIR UN ARCHIVO. ...............................................................................................................27
2.6.2. CERRAR EL ARCHIVO...............................................................................................................28
2.6.3. CONTROL DE FIN DE ARCHIVO ‘EOF’ ......................................................................................29
2.6.4. ACCESO DIRECTO O ALEATORIO (fseek). ................................................................................29
1
_____________________________________________________________________________
M.Cs. Ing. Julio Cesar Bermúdez Vargas
2.6.5. CONOCER LA POSICION ACTUAL DEL PUNTERO DE L/E. .........................................................30

2.6.6. RESTABLECER EL PUNTERO DE L/E AL PRINCIPIO. ..................................................................30
2.7. PASOS PARA EL PROCESAMIENTO DE ARCHIVOS. .....................................................................31
2.8. OPERACIONES BÁSICAS EN UN ARCHIVO. .................................................................................31
2.8. EJEMPLO DE APLICACIÓN DE ARCHIVOS DIRECTOS...................................................................34
BIBLIOGRAFIA ...................................................................................................................................44
2
_____________________________________________________________________________
PUNTEROS Y ESTRUCTURAS DINÁMICAS DE DATOS
Un puntero es una variable que contiene la dirección de memoria de un dato o de otra

variable que contiene al dato, es decir, que el puntero apunta al espacio físico donde está el
dato o la variable. Un puntero puede apuntar a un objeto de cualquier tipo, como por
ejemplo, a una estructura o a una función. Los punteros se pueden utilizar para referenciar y
manipular estructuras de datos, para referenciar bloques de memoria asignados
dinámicamente y para proveer el paso de argumentos por referencia en las llamadas a
funciones.
A diferencia de una variable normal (estática) que hace referencia directa al valor que
almacena, una variable puntero almacena la dirección de memoria del valor en la memoria,
es decir, realiza una referencia indirecta a los valores en la memoria. Los punteros sirven para
expresar direcciones de memoria y permiten modificar el contenido de la memoria a la que apuntan.
Cuando se trabaja con punteros son frecuentes los errores debidos a la creación de punteros
que apuntan a alguna parte inesperada, produciéndose una violación de memoria. Por lo
tanto, debe ponerse la máxima atención para que esto no ocurra, inicializando
adecuadamente cada uno de los punteros que utilicemos.
1.1. OPERADORES PARA EL MANEJO DE PUNTEROS.
Para el trabajo o procesamiento de punteros existe dos operados especiales que permiten el
acceso a los valores almacenados en la memoria y la utilización de la dirección de memoria
donde se encuentran los valores.
1.1.1. OPERADOR DE DIRECCION ‘&’.
Es un operador unitario que se aplica a una variable o a objetos como un elemento de un

vector o un campo de una estructura que pueden utilizarse en los mismos lugares en los que
se utiliza una variable. El resultado de la expresión “&x”, donde x es una variable, es la
dirección de memoria donde se almacena x.
3
_____________________________________________________________________________
Por ejemplo:
&p da como resultado la dirección de memoria de la variable p.
El resultado del operador ‘&’ se debe almacenar en una variable puntero o en una función
de salida.
1.1.2 OPERADOR DE INDIRECCION O CONTENIDO ‘*’.
Es un operador unitario que se aplica a un puntero. Dada una expresión de tipo puntero p, la
expresión ‘*p’ permite trabajar con la variable u objeto al que apunta p.
El resultado del operador ‘*’ es el contenido de la dirección de memoria (variable puntero)

a la que se aplica el operador.
Por ejemplo:
*pt da como resultado el valor o contenido de la dirección de memoria de

la variable puntero ‘pt’.
El siguiente programa muestra el efecto resultante del uso de los operadores de dirección y
de indirección.
#include <stdio.h>
int void main()
{
//declaración de variables estáticas y dinamicas
int a = 5, b, *p;
p = &a; // asigna la dirección de a, a la variable p
// p apunta a la variable entera a
b = *p; // asigna a b el valor de la variable a (contenido de la
//variable p)
printf("en la dirección %.4X está el dato %d\n". p, b);
printf("En la dirección %.4X está el dato %d\n", p, *p);
return 0;
}
1.2. DECLARACIÓN DE PUNTEROS.
Un puntero se declara anteponiendo al identificador que nombra al puntero, el modificador

*, el cual significa "puntero a". Un puntero inicializado correctamente siempre apunta a un
objeto de un tipo particular. Un puntero no inicializado no se sabe a que apunta. La sintaxis
para declarar un puntero es:
4
_____________________________________________________________________________
Tipo *var_puntero;
Donde Tipo especifica el tipo del objeto apuntado, puede ser cualquier tipo incluyendo
tipos definidos por el usuario y var_puntero es el identificador de la variable puntero.
Por ejemplo:
int a;
int *pt;
a es una variable entera

pt es un puntero a un entero
pt es igual a la dirección de a, entonces pt apunta a la variable a
float *pf; //pf es un puntero a un real

char *pc; //pc es un puntero a un carácter
El espacio de memoria requerido para un puntero, es el número de bytes necesarios para

especificar una dirección de memoria de la máquina. Son valores típicos 2 o 4 bytes.
1.2.1. ALMACENAMIENTO EN UNA VARIABLE PUNTERO.
En una variable punero se puede almacenar los siguientes valores:
a) DIRECCIONES DE MEMORIA.
Lo normal es almacenar direcciones de memoria de objetos que se emplea en el programa y

que son obtenidos por medio del operador de dirección ‘&’.
Por ejemplo:
int a=5,*p;
p=&a;
b) CONSTANTE NULL (PUNTERO NULO)
Sin importar el tipo de objeto al que apunta, a una variable puntero se le puede asignar la
constante NULL, esto significa que se tiene un puntero nulo, es decir, la variable puntero
no apunta a algo específico.
Por ejemplo:
int *pt;
5
_____________________________________________________________________________
float *pf;
pt=NULL;
pf=NULL;
c) VALOR CERO (0).
En una variable puntero se puede almacenar el valor cero (0) y es equivalente a almacenar
la constante NULL. El almacenamiento del valor 0 es el único permitido de los valores
enteros que se puede almacenar en una variable puntero. El siguiente programa muestra
estas posbles formas de almacenamiento:
#include <stdio.h>
#include <iostream.h>
int a=5,*pt,*pt1,*pt2;
main()
{
pt=&a;
pt1=NULL;
pt2=0;
cout<<"direccion:"<<pt<<"\tvalor:"<<*pt<<endl;
cout<<"direccion:"<<pt1<<endl;
cout<<"direccion:"<<pt2<<endl;
return 0;
}
Mostrando la siguiente salida:
1.3. OPERACIONES CON PUNTEROS.
El trabajo con punteros permite realizar un conjunto de operaciones que exigen mucho
cuidado en la compatibilidad de los objetos a los que apuntan. Se pueden realizar las
siguientes operaciones:
6
_____________________________________________________________________________
1.3.1. ASIGNACION.
Dos variables puntero se pueden asignar solo si son punteros al mismo tipo de objeto, es
decir, las dos variables puntero deben ser compatibles.
Por ejemplo:
int a=5, *p,*q;
p=&a;
q=p;
En este ejemplo, la variable puntero p recupera la dirección de memoria de ‘a’, es

decir, ‘p’ apunta a la variable ‘a’ y la variable puntero q recibe la dirección de
memoria de la variable ‘p’, por lo que tanto ‘p’ y ‘q’ apuntan a la misma variable ‘a’.
No es posible asignar dos variables puntero si no apuntan al mismo tipo de objeto, el

siguiente ejemplo produce un error:
int a=5,*pt;
float *pf;
pt=&a;
pf=pt; // error de incompatibilidad de tipo.
Como ‘pt’ y ‘pf’ son punteros a diferentes tipos de objetos, la asignación de ambas
variables produce un error.
Una Variable puntero, sea cualquiera el objeto al que apunta, se puede asignar con la
constante NULL (puntero nulo).
pt=NULL;
‘pt’ apunta a nulo, es decir, apunta a nada.
1.3.2. COMPARACION.
Dos variables puntero se pueden comparar solo sin son compatibles, es decir, si ambas
variables apuntan al mismo tipo de objeto. Cuando dos variables puntero se comparan solo
es útil el empleo de los operadores de relación igual que (==) y distinto que (!=), el empleo
de otros operadores no tiene sentido.
7
_____________________________________________________________________________
Por ejemplo:
int *p,*q;
…..
if (p==q)
……..
if (p!=q)
…….
Una Variable puntero, sea cualquiera el objeto al que apunta se puede comparar con la
constante NULL (puntero nulo).
if (p==NULL)
……..
if (p!=NULL)
……..
No es posible comparar dos variables puntero que apuntan a objetos diferentes,

produciendo un error de tipología de datos.
1.3.3. ARITMETICA CON PUNTEROS.
Las únicas operaciones aritméticas permitidas con punteros son el incremento o suma y el
decremento o resta. Tanto el incremento o decremento se realiza únicamente con valores
enteros. Se debe tomar en cuenta que la dirección de memoria almacenada en un puntero
está representada en sistema de numeración hexadecimal.
a) INCREMENTO O SUMA.
Si ‘p’ es un puntero a entero, entonces almacena una dirección de memoria donde se

localiza un valor entero. Si a ‘p’ se le incrementa 1, entonces se logra que ‘p’ apunte al
entero siguiente, por lo tanto la dirección de memoria de ‘p’ se incrementa en 2 o 4
dependiendo del tamaño de memoria en bytes que ocupa un valor entero en la memoria del
computador.
8
_____________________________________________________________________________
Por ejemplo:
int a=5,*pt;
pt=&a;
pt=pt+1; //pt apunta al en tero siguiente
pt=pt+3; //pt apunta al tercer entero más adelante
NOTA:
 la operación de incremento es recomendable realizarla cuando se accede a
los valores de un arreglo unidimensional por medio de las direcciones de
memoria.
 El incremento se realiza en sistema de numeración hexadecimal.
a) DECREMENTO O RESTA.
Si ‘p’ es un puntero a entero, entonces almacena una dirección de memoria donde se

localiza un valor entero. Si a ‘p’ se le decrementa 1, entonces se logra que ‘p’ apunte al
entero anterior, por lo tanto la dirección de memoria de ‘p’ se decrementa en 2 o 4
dependiendo del tamaño de memoria en bytes que ocupa un valor entero en la memoria del
computador.
Por ejemplo:
int a=5,*pt;
pt=&a;
pt=pt-1; //pt apunta al entero anterior
pt=pt-3; //pt apunta al tercer entero más atrás
9
_____________________________________________________________________________
NOTA:
 la operación de decremento es recomendable realizarla cuando se accede a
los valores de un arreglo unidimensional por medio de las direcciones de
memoria.
 El decremento se realiza en sistema de numeración hexadecimal.
En términos generales, si a un puntero se le Incrementa/Decrementa 1 (uno), entonces el

puntero avanza o retrocede al objeto siguiente o anterior respectivamente y por lo tanto la
dirección de memoria del puntero se incrementa/decrementa en el valor que corresponde al
tamaño en bytes que ocupa en la memoria del objeto al que apunta.
1.4. PUNTEROS Y ARREGLOS.
Existe una relación muy importante entre punteros y arreglos, por lo que es posible acceder
y procesar la información de un arreglo por medio de las direcciones de memoria del
arreglo sin necesidad de emplear la notación de sub índices.
El nombre de un arreglo representa la dirección de memoria donde empieza el arreglo en la

memoria, tomando en cuenta esta consideración y por medio de las operaciones de
incremento o decremento en una variable puntero, se puede procesar la información
almacenada en el arreglo empleando punteros.
Por ejemplo:
int a[5]={3,6,2,8,1};
int *pt;
pt=a; //pt apunta al primer elemento del arreglo ‘a’
cout<<*pt; //muestra el primer valor del arreglo ‘a’, 3
cout<<*(pt+1); // muestra el segundo valor del arreglo ‘a’, 6
cout<<*(pt+2); // muestra el tercer valor del arreglo ‘a’, 2
cout<<*(pt+3); // muestra el cuarto valor del arreglo ‘a’, 8
cout<<*(pt+4); // muestra el quinto valor del arreglo ‘a’, 1
10
_____________________________________________________________________________
El siguiente programa ilustra el procesamiento de la información de un arreglo

unidimensional y de un arreglo bi dimensional por medio de sub índices y por medio de las
direcciones de memoria, asimismo muestra el tamaño de las variables de los tipos
fundamentales del c++.
int a[10]={5,2,8,1,4};
int a1[5][10]={{2,4,1},{8,1,3},{3,7,1}};
void imprimir(int x[],int y)
{
cout<<"\n CONTENIDO DEL VECTOR POR MEDIO DE DIR. DE MEMORIA";
int *pt;
pt=x;
int i;
for (i=0;i<y;i++)
cout<<"\nvalor="<<*(pt+i)<<"\tdir. de memoria="<<(pt+i);
}
void impmat(int x[][10],int f,int c)
{
int *pt;
int i,j;
cout<<"\n matriz por medio de dir. de memoria";
pt=x[0];
for (i=0;i<f;i++)
for (j=0;j<c;j++)
cout<<"\n valor="<<*((pt+i*10)+j)<<"\tdir. de memoria="<<((pt+i*10)+j);
}
main()
{
int i;
cout<<"\ncontenido del vector por medio de sub indices";
for (i=0;i<5;i++)
cout<<"\nvalor = " <<a[i];
imprimir(a,5);
impmat(a1,3,3);
int p=5,*pt;
float f=6.9,*pf;
char c='a',*pc;
cout<<"\ntamaño de un entero="<<sizeof(int);
cout<<"\ntamaño de un real="<<sizeof(float);
cout<<"\ntamaño de un caracter="<<sizeof(char);
cout<<"\ntamaño de un entero largo="<<sizeof(long);
cout<<"\ntamaño de un real doble="<<sizeof(double);
11
_____________________________________________________________________________
pt=&p;
pf=&f;
pc=&c;
cout<<"\nvalor de p="<<*pt<<"\t dir de memoeria="<<pt;
cout<<"\nvalor de f="<<*pf<<"\t dir de memoeria="<<pf;
cout<<"\nvalor de c="<<*pc<<"\t dir de memoeria="<<&pc;
pt=pt-2;
cout<<"\nnuevo valor de pt ="<<pt;
return 0;
}
Produciendo la siguiente salida:
NOTA: en el programa ejecutado, por la versión del IDE, el tamaño que ocupa un valor
entero en la memoria es de 2 bytes,.
La función ‘imprimir’ muestra el contenido del vector por medio de las direcciones de
memoria empleando una variable puntero.
La función ‘impmat’ muestra el contenido de una matriz de un tamaño de 5 filas y 10

columnas, aunque solo se almacena datos en las tres primeras filas y columnas, por medio
de las direcciones de memoria.
1.4.1. PUNTERO A CADENA DE CARACTERES.
Puesto que una cadena de caracteres es un array de caracteres, es correcto pensar que la
teoría expuesta anteriormente, es perfectamente aplicable a cadenas de caracteres.
12
_____________________________________________________________________________
La forma de definir un puntero a una cadena de caracteres es:
char *cadena;
El identificador del array de caracteres es la dirección de comienzo del array y para que una
función manipuladora de una cadena de caracteres pueda saber dónde finaliza dicha cadena,
el compilador añade al final de la cadena el carácter ‘\0’.
El siguiente ejemplo define e inicializa la cadena de caracteres nombre:
#include <stdio.h>
int longcad(char *cad)
{
char *p = cad;
while (*p != '\0')
p++;
return (p - cad);
}
void main ( )
{
char *nombre = "abcd"; //el carácter de terminación '\0' se añade
automáticamente
printf(“\n la longitud de la cadena es: %d \n”,longcad(nombre));
}
El valor (p – cad) devuelto por la función longcad, da la longitud de la cadena. Esta función
realiza las siguientes operaciones:
1. Asigna a p la dirección del primer carácter de la cadena, que coincide con la dirección de
comienzo de la misma, e inicia la ejecución del bucle while.
2. Cuando se ejecuta la condición del bucle while, se compara el carácter *p apuntado por p
con el carácter nulo (\0). Si *p es el carácter nulo el bucle finaliza; si no, se incrementa el
valor de p en una unidad para que apunte al siguiente carácter, y se vuelve a evaluar la
condición.
13
_____________________________________________________________________________
1.4.2. PUNTEROS A ESTRUCTURAS.
En un puntero se puede almacenar la dirección de memoria de cualquier tipo de dato, sea

simple o compuesto, una estructura es un tipo de dato compuesto, por lo que un puntero a
una estructura es similar a la declaración de un puntero a otro tipo de dato. Se emplea el
siguiente formato:
Tipo_estructura *puntero;
struct persona
{
int ci;
char nombre[20];
float est;
};
struct persona *pp;
donde ‘pp’ es un puntero a estructura tipo persona.
Struct fecha
{
int dia;
int mes;
int anio;
};
struct fecha *pf;
Donde ‘pf’ es un puntero a estructura fecha.
El acceso a los miembros o campos de una estructura por medio del puntero se realiza
empleando el operador flecha (->).
Por ejemplo:
pp->ci; hace referencia al campo `ci’ de la estructura persona.

pp->nombre; hace referencia al campo `nombre’ de la estructura persona.
pp->est; hace referencia al campo `est’ de la estructura persona.
El siguiente programa muestra la declaración de una estructura fecha y un puntero a esa

estructura, asimismo el acceso a los campos por medio del operador flecha (->)
#include <stdlib.h>
14
_____________________________________________________________________________
struct fecha
{
int dd;
int mm;
int aa;
};
void leer(struct fecha *f)

{
cout<<"\nDia:";
cin>>f->dd;
cout<<"\nMes:";
cin>>f->mm;
cout<<"\nAño:";
cin>>f->aa;
}
void imprimir(struct fecha *f)
{
cout<<"\nDia:"<<f->dd;
cout<<"\nMes:"<<f->mm;
cout<<"\nAño:"<<f->aa;
}
int main()
{
struct fecha *d;
d=(struct fecha *)malloc(sizeof(struct fecha));
leer(d);
imprimir(d);
return 0;
}
La salida del programa anterior es:
Notar que para usar un puntero se debe solicitar memoria dinámica por medio de la
función ‘malloc’.
15
_____________________________________________________________________________
1.5. ESTRUCTURAS DINÁMICAS DE DATOS. LISTAS SIMPLES.
Una de las aplicaciones más interesantes y potentes de la memoria dinámica y los

punteros son las estructuras dinámicas de datos. Las estructuras básicas disponibles en C
y C++ tienen una importante limitación: no pueden cambiar de tamaño durante la
ejecución. Los arreglos están compuestos por un determinado número de elementos,
número que se decide en la fase de diseño, antes de que el programa ejecutable sea
creado.
En muchas ocasiones se necesitan estructuras que puedan cambiar de tamaño durante la

ejecución del programa, se puede crear 'arrays' dinámicos, pero una vez creados, el
tamaño también será fijo, y para hacer que crezcan o disminuyan de tamaño, se debe
reconstruirlas desde el principio.
Una lista simple abierta tiene la siguiente forma:
Por ejemplo:
Definición:
Una lista encadena simple es un conjunto finito de elementos autoreferenciados llamados

nodos, donde cada nodo se conecta al siguiente por medio de un campo de enlace.
Además:
 Existe un puntero ‘raiz’ que almacena la dirección del primer nodo.

 Cada nodo se conecta al siguiente por medio de un enlace (puntero).
 Todos los nodos, excepto el último, tienen un solo nodo sucesor.
 Todos los nodos, excepto el primero tienen un solo nodo antecesor, el cual no es
accesible desde el nodo.
 El campo enlace del ultimo nodo apunta a nulo.
 Son estructuras secuenciales unidireccionales.
16
_____________________________________________________________________________
Estructura de un nodo:
Un nodo tiene dos campos: para el almacenamiento de la información (info) y para el

enlace al siguiente nodo (sig)
struct Nodo
{
int info;
Nodo *sig;
};
typedef Nodo *NNodo;
La lista existe a partir de la variable puntero llamada ‘raiz:
RaízNULL lista vacía.
1.5.1. OPERACIONES BASICAS EN UNA LISTA SIMPLE.
En una lista simple se puede realizar las siguientes operaciones básicas:
 Creación: Normalmente la lista se crea vacía.

 Adición: se aumenta un nodo a la lista y puede ser al principio, al final o en una lista
ordenada.
 Eliminación: se elimina un nodo de la lista y puede ser el primero, el último o un
nodo de referencia.
 Recorrido: es el acceso a todos los nodos de la lista con un propósito determinado.
 Búsqueda: para verificar si una valor está o no en la lista.
ADICION.
Se aumenta un nodo en la lista. En la siguiente ilustración se adiciona al principio de

la lista.
Se considera un nodo a insertar, con un puntero que apunte a él, y de una lista, en este
caso puede ser vacía o no vacía:
 Pedir memoria en un puntero ‘nuevo’

 Almacenar la información ‘dato’ en el campo info.
 El campo ‘sig’ del ‘nuevo’ nodo apunta a la ’raiz’
 La ‘raiz’ apunta al nodo ‘nuevo’
17
_____________________________________________________________________________
ELIMINACION.
Se quita un nodo de la lista. En la siguiente ilustración se quita el primer nodo de la lista. Se

asume que la lista no está vacía.
 Se apunta al primer nodo con el puntero ‘pt’

 Se recupera el valor del campo ‘info’ del nodo ‘pt’
 ‘raiz’ apunta al siguiente nodo.
 Retornar el valor.
RECORRIDO.
El recorrido es el acceso a todos los nodos sin afectar la estructura, se debe emplear una
variable puntero de apoyo ‘pt’.
 ‘pt’ apunta a la ‘raiz’.

 Mientras ‘pt’ sea distinto de NULL
o Procesar la información de ‘pt’
o Recorrer al siguiente nodo.
BUSQUEDA.
Consiste en verificar si un valor está o no en la lista, esta operación es muy similar al

recorrido pero con la variante de que el proceso finaliza cuando se encuentra el valor
buscado o cuando se llega al final de la lista.
El siguiente programa ilustra las operaciones básicas descritas anteriormente.
El esquema de la clase se implementa en un archivo ‘.h’
struct Nodo
{
int info;
Nodo *sig;
};
typedef Nodo *NNodo;
class listasimple
{
Nodo *raiz;
public:
listasimple();
void crear();
int esvacia();
18
_____________________________________________________________________________
void adicion(int);
int eliminar();
NNodo buscar(int);
void recorrido();
};
La implementación de la funciones de la clase se realiza en un programa ‘.cpp’
#include <d:\sis2210a\listas\lisimple.h>
#include <stdlib.h>
#include <stdio.h>
//funcion constrauctora asigna NULL a la variable 'raiz'
// crea la lista vacia (raiz=NULL)
listasimple::listasimple()
{
raiz=NULL; //la lista se crea vacia
};
//la funcion crear, crea la lista vacia

//asigna el valor NULL a la variable raiz;
void listasimple::crear()
{
raiz=NULL;
}
// la funcion estado verifica si la lista esta vacia o no.
// retorna 1 si la lista esta vacia y 0 en caso contrario.
int listasimple::esvacia()
{
return (raiz==NULL);
}
//la funcion adicion aumenta un nodo al principio de la lista

// el nuevo nodo se constituira en el primero de la lista
void listasimple::adicion(int dato)
{
Nodo *nuevo;
nuevo=(Nodo *)malloc(sizeof(Nodo));
nuevo->info=dato;
nuevo->sig=raiz;
raiz=nuevo;
}
//la funcion eliminar recupera el valor del primer nodo de la lista
// y elimina ese nodo liberando memoria
//la fincion de eliminacion se invoca luego de verificar que la lista no este vacia.
int listasimple::eliminar()
{
19
_____________________________________________________________________________
Nodo *pt;
pt=raiz;
int dato;
dato=raiz->info;
raiz=raiz->sig;
free(pt);
return dato;
}
// la funcion buscar verifica si un valor esta o no en la lista
// retorna NULL si el valor no esta den la lista y retorna distinto a NULL
// si el valor esta en la lista.
NNodo listasimple::buscar(int valor)
{
Nodo *pt=raiz;
while (pt!=NULL && valor!=pt->info)
pt=pt->sig;
return pt;
}
//la funcion recorrido accede a todos los nodos de la lista
//con un proposito determinado sin modificar la lista.
void listasimple::recorrido()
{
Nodo *pt=raiz;
cout<<"\nCONTENIDO DE LA LISTA:\n";
while (pt!=NULL)
{
cout<<pt->info<<"--->";
pt=pt->sig;
};
cout<<"null\n";
}
La implementación de objetos en un tercer archivo ‘.cpp’
#include <d:\sis2210a\listas\lisimple.cpp>
#include <stdlib.h>
#include <stdio.h>
main()
{
listasimple li;
li.crear();
li.adicion(11);
li.adicion(8);
li.adicion(17);
li.recorrido();
20
_____________________________________________________________________________
int dat=li.eliminar();
cout<<"\n valor eliminado :"<<dat;
li.recorrido();
return 0;
}
La salida de la aplicación es la siguiente:
NOTA: los programas deben estar en la siguiente ruta: d:\sis2210a\listas\
21
_____________________________________________________________________________
ARCHIVOS
Todos los programas realizados hasta ahora obtenían los datos necesarios para su ejecución
de la entrada estándar (TECLADO) y visualizaban los resultados en la salida estándar
(PANTALLA). Por otra parte, el programa retiene los datos que manipula mientras esté en
ejecución; es decir, los datos introducidos se pierden cuando el programa finaliza.
La solución para hacer que los datos persistan de una ejecución para otra es almacenarlos
en un fichero o archivo en el disco, en vez de en un array en memoria. Entonces, cada vez
que se ejecute el programa que trabaja con esos datos, podrá leer del archivo los que
necesite y manipularlos. Nosotros procedemos de forma análoga en muchos aspectos de la
vida ordinaria; almacenamos los datos en fichas y guardamos el conjunto de fichas en 1o
que generalmente denominamos fichero o archivo.
2.1. DEFINICION.
Desde el punto de vista informático, un archivo es una colección de información que

almacenamos en un soporte magnético para poder manipularla en cualquier momento. Esta
información se almacena como un conjunto de registros (estructuras), conteniendo todos
ellos los mismos campos (miembros de la estructura). Cada campo almacena un dato de un
tipo predefinido o definido por el usuario.
Un archivo es un conjunto de información relacionada, manejada como unidad y que se

dispone en un dispositivo de almacenamiento secundario.
2.2. PROPIEDADES DE UN ARCHIVO.
Todo archivo localizado en un dispositivo de almacenamiento secundario tiene las

siguientes propiedades:
22
_____________________________________________________________________________
NOMBRE.
Es un conjunto de caracteres que identifica el contenido del archivo, no puede

exceder los 8 caracteres, es decir es un identificador valido.
 El primer carácter es una letra.

 No contiene espacios en blanco.
 No contiene operadores aritméticos.
 No contiene operadores de relación.
 No es una palabra reservada del lenguaje o del sistema.
EXTENSIÓN.
Normalmente es un conjunto de tres caracteres que establece el tipo de archivo en el

dispositivo de almacenamiento secundario.
.exe Archivo ejecutable intersegmentario.

.com Archivo ejecutable unisegmentario.
.bat Archivo de ejecución por lotes.
.sys Archivo de configuración del sistema.
.*** Archivo del usuario.
.cpp
.pas
.doc
.xls
.ppt
.dat archivo de datos del usuario.
TAMAÑO.
Todo archivo ocupa un espacio en el dispositivo magnético y normalmente se

expresa en bytes.
LOCALIZACION O PATH.
Un archivo se localiza en algún lugar del dispositivo de almacenamiento secundario,

se denomina también ruta del archivo.
FECHA DE CREACION/MODIFICACION/ULTIMO ACCESO.
El sistema operativo almacena automáticamente estas fechas de procesamiento del

archivo.
PUNTERO DE LECTURA/ESCRITURA.
23
_____________________________________________________________________________
Permite el acceso al contenido del archivo y se desplaza automáticamente cada vez

que se realiza una operación de lectura y escritura, el comportamiento del puntero
de L/E del archivo varia dependiendo de la forma de organización del archivo.
FIN DE ARCHIVO.
Al final del contenido de un archivo existe una marca de finalización EOF (End Of
File) que evita que se afecte otros sectores de memoria que no pertenecen al archivo.
2.3. ORGANIZACIÓN DE UN ARCHIVO.
La organización de un archivo define la forma de almacenamiento de la información en el

medio magnético, al mismo tiempo establece el comportamiento que tendrá el puntero de
lectura y escritura del archivo y la forma de lectura y escritura de información en el archivo.
Básicamente se tiene dos formas de organización de un archivo que determina la forma de

acceso a la información contenida en el mismo.
2.3.1. ORGANIZACIÓN SECUENCIAL.
La organización secuencial se caracteriza porque la información se graba como una

secuencia de caracteres, es decir, son archivos de texto. Tienen las siguientes
características:
 Ocupan un bloque compacto y contiguo de memoria.

 Los registros lo constituyen líneas de texto que son de diferente longitud.
 No tiene significancia el desplazamiento arbitrario del puntero de lectura y escritura,
es decir, el puntero de L/E se desplaza automáticamente cada vez que se realiza una
lectura o escritura en el archivo.
 La información se lee o graba por: caracteres, palabras o por cadenas de caracteres
(líneas de texto).
 El acceso a la información es secuencial.
24
_____________________________________________________________________________
2.3.2. ORGANIZACIÓN DIRECTA/RANDOMICA O ALEATORIA.
La Organización Directa/Aleatoria/Randómica se caracteriza porque la información se

graba por bloques del mismo tamaño, corresponde a los archivos de datos tipeados. Tiene
las siguientes características:
 Ocupan bloques dispersos y aleatorios de memoria.

 Los registros tienen el mismo tamaño y corresponden a tipos de datos predefinidos
o definidos por el usuario.
 Cada registro tiene una dirección de registro.
 El Puntero de L/E se puede desplazar arbitrariamente por medio de la dirección del
registro.
 Establece un Acceso Directo a la información del archivo, es decir, para localizar
un registro se puede emplear la dirección del registro y no es necesario recorrer toda
la información previa.
 El archivo es similar a una tabla donde las columnas lo constituyen los campos de la
estructura y las filas lo constituyen los registros del archivo.
 La Lectura y Escritura de información se realiza por bloques del mismo tamaño.
 El acceso a la información es directa.
2.4. USO DE ARCHIVOS.
La información contenida en un archivo, normalmente tiene 2 usos fundamentales:
a) CONSULTAS.
25
_____________________________________________________________________________
Se puede acceder a la información contenida en el archivo por medio de algún

criterio de consulta, ya sea para reportes o para algún otro proceso especifico. Se
puede consultar toda la información del archivo o simplemente alguna porción de la
información.
b) ACTUALIZACION.
La información contenida en el archivo debe reflejar cierta realidad en un momento

específico, es decir debe ser actualizada, para lograr que la información este
actualizada se realiza operaciones de ADICION, MODIFICACION Y
ELIMINACION.
2.5. ENTRADA Y SALIDA EN ARCHIVOS.
La Entrada y Salida en un archivo, conocido también como Lectura y Escritura, se realiza

de maneras diferentes dependiendo de la organización del archivo. Puede ser de la siguiente
manera:
2.6. PROCESAMIENTO DE ARCHIVOS EN EL DISCO.
Para poder escribir o leer sobre un fichero, primeramente hay que abrirlo. El fichero puede
ser abierto para leer, para escribir o para leer y escribir.
En C y en C++ abrir un fichero significa definir un stream (flujo) que permita el acceso al
fichero en el disco para leer o escribir. La definición del stream supone la definición de un
buffer (memoria intermedia) para conectar el stream con el fichero en el disco. Esto permite
referirse al stream como si fuera el fichero (más adelante veremos que un stream se define
como un puntero a una estructura de tipo FILE).
26
_____________________________________________________________________________
2.6.1. ABRIR UN ARCHIVO.
Para poder escribir o leer de un archivo, primeramente hay que abrirlo con las funciones
fopen o freopen. El fichero puede ser abierto para leer, para escribir o para leer y escribir.
Cuando un programa comienza su ejecución, son abiertos automáticamente tres ficheros,

que se corresponden con otros tres dispositivos. Estos ficheros, direccionados por streams,
y los dispositivos asociados por defecto son:
Para la apertura de un archivo es necesario declarar un puntero a una estructura del tipo
FILE, este puntero se constituye en el stream que se emplea en el programa.
Por ejemplo:
FILE *arch;
La función ‘fopen’ abre un archivo especificado para un modo determinado.
fopen(“nombre-archivo”,”modo-aperttura”)
Por ejemplo:
arch = fopen (“medicina.dat”,”wb”);
el puntero ‘arch’ captura el resultado de la apertura del archivo ‘medicina.dat’ para el modo
de escritura (w) y en formato binario(b).
Los diferentes modos de apertura de un archivo o fichero son los que se ilustran en la
siguiente tabla:
27
_____________________________________________________________________________
Es recomendable utilizar, adicionalmente, el modo binario ‘b’ que se adiciona al modo de

apertura descrito en la tabla anterior. Si no se especifica el modo binario ‘b’, entonces el
lenguaje asume que el archivo se abre en modo texto (t).
La función fopen devuelve un puntero a una estructura de tipo FILE que define, entre otros
datos, el buffer asociado con el fichero abierto. Un puntero nulo indica un error en la
apertura. El puntero devuelto por fopen recibe el nombre de stream y es utilizado por las
funciones estándar de E/S para leer y escribir datos en un archivo. Por esta razon, antes de
invocar a la función fopen hay que definir un puntero que apunte a una estructura de tipo
FILE.
Por ejemplo:
FILE *arch;
arch = fopen("datos", "w");
if (arch== NULL)
printf("Error: el fichero no se puede abrir\n");
2.6.2. CERRAR EL ARCHIVO.
Después de realizar las tareas de procesamiento en el archivo, es necesario cerrar el archivo

con la función ‘fclose’. Si un archivo no se cierra explícitamente, el lenguaje se encarga de
cerrarlo automáticamente una vez finalizada la ejecución del programa. Sin embargo es
recomendable cerrar el archivo durante la ejecución de un programa debido a que existe un
límite para mantener archivos abiertos simultáneamente.
La función ‘fclose’ cierra el stream que se especifica.
28
_____________________________________________________________________________
Por ejemplo:
fclose(arch);
2.6.3. CONTROL DE FIN DE ARCHIVO ‘EOF’
El sistema incorpora una marca de fin de archivo EOF automáticamente cuando el archivo
es creado y si se intenta leer un archivo más allá de la marca de fin de archivo, entonces se
activa el indicador de fin de archivo.
La función ‘feof’ determina el estado del indicador de fin de archivo. La función feof
devuelve un valor distinto de 0 cuando se intenta leer un elemento del archivo y nos
encontramos con un eof (end of file - fin de fichero), en caso contrario devuelve un 0.
Por ejemplo:
while (!feof(arch)) // mientras no se llegue al final del archivo ‘arch’
….
2.6.4. ACCESO DIRECTO O ALEATORIO (fseek).
Normalmente el acceso a la información de un archivo es de manera secuencial, es decir,

primero se accede al primer registro, luego al segundo, luego al tercero y así sucesivamente
hasta llegar al final del archivo, sin embargo en archivos con organización directa es
posible acceder a cualquier registro del archivo sin necesidad de acceder a los registros
anteriores.
La función ‘fseek’ permite desplazar el puntero de Lectura/Escritura de un puntero

asociado a un archivo a una nueva localización desplazando cierta cantidad de bytes a partir
de una posición dada.
El formato de la función ‘fseek’ es el siguiente:
int fseek(File *p, long desp, int pos);
Desplaza el puntero de L/E de ‘p’ ‘desp’ bytes a partir de la posición ‘pos’
Generalmente ‘desp’ es un valor entero mayor o igual a 0 y es un múltiplo del

tamaño en bytes del registro que se almacena en el archivo.
La posición ‘pos’ a partir de la cual se desplaza el puntero de L/E puede tomar

alguno de los siguientes valores:
29
_____________________________________________________________________________
La función ‘fseek’ retorna un valor 0 si no se ha producido un error y retorna un valor

distinto a 0 si existe un error.
Por ejemplo:
fseek(arch,0,SEEK_END);
Esta instrucción desplaza el puntero de L/E de ‘arch’ 0 bytes a partir del final del
archivo, es decir, lleva el puntero de L/E de ‘arch’ al final del archivo.
2.6.5. CONOCER LA POSICION ACTUAL DEL PUNTERO DE L/E.
Si se desea conocer la posición actual del puntero de L/E del archivo se debe emplear la
función ‘ftell’. El valor o posición que retorna ‘ftell’ es un entero relativo al principio del
archivo.
La función ‘ftell’ tiene el siguiente formato:
long ftell(FILE *p);
Por ejemplo:
posi=ftell(arch);
Almacena en la variable ‘posi’ la posición actual del puntero de L/E del archivo
apuntado por arch.
2.6.6. RESTABLECER EL PUNTERO DE L/E AL PRINCIPIO.
La función ‘rewind’ establece el puntero de L/E de un archivo al principio del archivo.
La función ‘rewind’ tiene el siguiente formato:
(void) rewind(FILE *p);

30
_____________________________________________________________________________
Por ejemplo:
rewind(arch);
Establece el puntero de L/E de ‘arch’ al principio del archivo.
Es equivalente a ejecutar la siguiente instrucción:
fseek(arch,0,SEEK_SET);
2.7. PASOS PARA EL PROCESAMIENTO DE ARCHIVOS.
El Procesamiento de la información contenida en un archivo, independientemente del

lenguaje de programación, estable el cumplimiento de los siguientes pasos:
1. Definir la estructura del registro del archivo.

2. Declarar un puntero a archivo
3. Abrir el archivo
4. Procesar la información del archivo:
a. Lectura
b. Escritura
c. control de fin de archivo
d. desplazar el puntero de lectura y escritura del archivo
e. conocer la posición actual del puntero de L/E
f. etc.
5. Cerrar el archivo.
Generalmente los pasos 1 y 2 se realizan una vez pero los pasos 3, 4 y 5 se realizan cada
vez que se manipula la información del archivo.
2.8. OPERACIONES BÁSICAS EN UN ARCHIVO.
Existe un conjunto de operaciones básicas que se desarrollan en un archivo.
a) CREACIÓN.
Normalmente un archivo se crea vacío. Se debe ejecutar las siguientes acciones:
 Abrir el archivo para escritura (“wb”)

 Cerrar el archivo.
31
_____________________________________________________________________________
b) ADICION DE REGISTROS.
La adición de registros consiste en aumentar un registro a partir del final del archivo
y se debe considerar las siguientes acciones:
 Abrir el archivo para adición (“ab+”).

 Leer la información de un registro desde el teclado o recuperar de otro
proceso.
 Grabar el registro en el archivo.
c) REPORTE GENERAL DE REGISTROS.
Muestra todos los registros del archivo, normalmente por pantalla.
 Abrir el archivo para lectura (“rb”).

 Leer todos los registros y mostrar por pantalla.
d) BUSQUE DE UN REGISTRO.
La operación de búsqueda consiste en determinar si un registro, a base de un campo

arbitrario, está o no en el archivo. Si está en el archivo retorna la posición del
registro en el archivo y retorna -1 en caso contrario.
 Abrir el archivo para lectura (“rb”).

 Leer los registros del archivo mientras no se llegue al final del archivo y el
registro buscado no sea encontrado.
 Determinar la posición del registro encontrado 0 -1 en caso contrario.
 Cerrar el archivo
 Retornar la posición determinada.
e) MODIFICACIÓN DE REGISTROS.
La operación de modificación de registros consiste en cambiar el contenido de uno o

más campos del registro, la nueva información se debe grabar en el mismo lugar del
registro en el archivo.
 Buscar el registro a modificar.

 Si el registro a modificar esta en el archivo, entonces
o Abrir el archivo para lectura y escritura (“rb+”).
o Posicionar el puntero de L/E en el lugar del registro.
o Leer el registro del archivo.
o Mostrar la información actual del registro.
o Leer la nueva información del registro.
32
_____________________________________________________________________________

o Grabar la nueva información del registro.
o Cerrar el archivo.
f) ELIMINACION LOGICA DE REGISTROS.
La eliminación lógica de registros consiste en desactivar el registro deseado, es

decir, la información no desaparece del archivo. Los registros del archivo tienen un
campo especial llamado ‘estado’, este campo almacena un valor 1 cuando el registro
está activo y almacena el valor 0 cuando el registro está inactivo, por lo tanto, la
eliminación lógica de registros consiste en almacenar el valor 0 en el campo estado
del registro deseado.
 Buscar el registro a eliminar en forma lógica.
 Si el registro a eliminar esta en el archivo, entonces
o Almacenar 0 en el campo estado.
g) ELIMINACION FISICA DE REGISTROS.
Esta operación se ejecuta muy pocas veces porque la información del registro
desaparece del archivo definitivamente. Regularmente solo se elimina físicamente
los registros que previamente han sido eliminados en forma lógica.
La eliminación física de registros supone el empleo de un archivo temporal. Se

copia al archivo temporal todos los registros del archivo original cuyo campo estado
es 1, luego se borrar el archivo original y se renombra el archivo temporal por el
nombre del archivo original
 Abrir el archivo original o principal para lectura (“rb”).

 Abrir el archivo temporal para escritura (“wb+”).
 Copiar todos los registros del archivo original al temporal con el campo
estado 1.
 Cerrar los dos archivos.
 Borrar el archivo original.
 Renombrar el archivo temporal.
h) RESTAURACION DE REGISDTROS ELIMINADOS EN FORMA LÑOGICA.
Un registro eliminado en forma lógica (inactivo) se puede restaurar para que este
activo nuevamente, esto significa que se debe almacenar 1 en el campo estado.
33
_____________________________________________________________________________
 Buscar el registro a restaurar.

 Si el registro a restaurar está en el archivo, entonces
o Almacenar 1 en el campo estado.
Este conjunto de operaciones básicas constituyen la base fundamental para el desarrollo de

otras operaciones con la información contenida en un archivo como ser: partición de
archivos, mezcla de archivo, clasificación de archivos, etc.
2.8. EJEMPLO DE APLICACIÓN DE ARCHIVOS DIRECTOS.
El programa siguiente implementa las operaciones básicas en un archivo de acceso directo.
1. DEFINICIÓN DE LA ESTRUCTURA DEL REGISTRO.
Para la presente ilustración se emplea el almacenamiento de información de medicamentos

con los siguientes campos:
 Código
 Nombre
 Precio
 Procedencia
 Estado
2. ESQUEMA DE LA CLASE
34
_____________________________________________________________________________
3. IMPLEMENTACION.
a) Esquema de la clase: ‘farmacia.h’
//definicion de la estructura del registro

struct producto
{
int cod;
char nombre[15];
float precio;
int proced;
int estado;
};
//definicion del esquema de la clase 'farmacia'
class farmacia
{
FILE *arch;
public:
void crear();
void adicion();
int buscar(int);
void modificar(int);
void elilogica(int);
void elifisica();
void reporte();
void reportei();
void reporteesp(int);
void restaurar(int);
};
b) Implementación de los métodos o funciones de la clase farmacia: ‘farmacia.cpp’
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <e:/jcbv/materia/sis2210/sis2210prog/archivosc++/farmacia.h>
//CREACION DE UN ARCHIVO
//EL ARCHIVO SE CREA VACIO.
void farmacia::crear()
{
arch=fopen("e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.dat","wb");
if (arch==NULL)
cout<<"\n ERROR EN LA APERTURA DEL ARCHIVO\n";
else
35
_____________________________________________________________________________
cout<<"\n ARCHIVO CREADO CON EXITO, FELICIDADES\n";
cout<<"\n presione cualquier tecla para continuar: ";
getch();
}
//ADICION DE REGISTRO.
//ADICIONA UN REGISTRO A PARTIR DEL FINAL DEL ARCHIVO
void farmacia::adicion()
{
producto reg;
arch=fopen("e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.dat","ab+");
if (arch==NULL)
else
{
clrscr();
cout<<"\n ADICION DE UN REGISTRO EN EL ARCHIVO\n";
cout<<"\n codigo del MEDICAMENTO:";
cin>>reg.cod;
cout<<"\n NOMBRE del MEDICAMENTO:";
cin>>reg.nombre;
cout<<"\n PRECIO del MEDICAMENTO:";
cin>>reg.precio;
cout<<"\n PROCEDENCIA del MEDICAMENTO 0:NACIONAL; 1: IMPORTADO:";
cin>>reg.proced;
reg.estado=1;
fwrite(&reg,sizeof(struct producto),1,arch);
cout<<"\nregistro grabado con exito\n";
fclose(arch);
getch();
};
}
//REPORTE GENERAL DEL ARCHIVO

void farmacia::reporte()
{
producto reg;
arch=fopen("e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.dat","rb");
if (arch==NULL)
else
{
clrscr();
cout<<"\n REPORTE DE LOS REGISTROS activos DEL ARCHIVO\n";
cout<<"\nCODIGO NOMBRE PRECIO PROCDEDENCIA ESTADO";
cout<<"\n===================================================";
fread(&reg,sizeof(struct producto),1,arch);
while (!feof(arch))
{
if (reg.estado==1)
printf("\n%5d %15s %5.2f %4d %4d",reg.cod,reg.nombre,reg.precio,reg.proced,reg.estado);
//cout<<"\n"<<reg.cod<<" "<<reg.nombre<<" "<<reg.precio<<" "<<reg.proced<<"
"<<reg.estado;
};
36
_____________________________________________________________________________
cout<<"\n===================================================";
cout<<"\npresione cualquier tecla para continuar:";
getch();
fclose(arch);
};
}
// reporte de registros inactivos

void farmacia::reportei()
{
producto reg;
if (arch==NULL)
else
{
clrscr();
cout<<"\n REPORTE DE LOS REGISTROS INactivos DEL ARCHIVO\n";
cout<<"\n===================================================";
while (!feof(arch))
{
if (reg.estado==0)
cout<<"\n"<<reg.cod<<" "<<reg.nombre<<" "<<reg.precio<<" "<<reg.proced<<"
"<<reg.estado;
};
cout<<"\n===================================================";
getch();
fclose(arch);
};
}
//BUSQUEDA DE UN REGISTRO EN EL ARCHIVO

//LA BUSQUEDA SE REALIZA POR MEDIO DEL CAMPO CODIGO
int farmacia::buscar(int clave)
{
producto reg;
int sw=0,res;
if (arch==NULL)
else
{
while (!feof(arch) && sw==0)
{
if (clave==reg.cod)
sw=1;
};
if (sw==0)
res=-1;
37
_____________________________________________________________________________
else
res=ftell(arch)-sizeof(struct producto);
fclose(arch);
}; return res;
}
//MODIFICA UN REGISTRO DEL ARCHIVO

void farmacia::modificar(int clave)
{
producto reg;
int res;
res=buscar(clave);
if (res==-1)
cout<<"\n El registro N0 esta en el archivo\n";
else
{
arch=fopen("e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.dat","rb+");
if (arch==NULL)
else
{
clrscr();
cout<<"\n CONTENIDO ACTUAL DEL REGISTRO EN EL ARCHIVO\n";
fseek(arch,res,SEEK_SET);
fread(&reg,sizeof(producto),1,arch);
cout<<"\n===================================================";
"<<reg.estado;
cout<<"\n===================================================";
cout<<"\nINTRODUCIR LA NUEVA INFORMACION DEL MEDICAMENTO:\n";
cout<<"\n NOMBRE del MEDICAMENTO:";
cin>>reg.nombre;
cout<<"\n PRECIO del MEDICAMENTO:";
cin>>reg.precio;
cout<<"\n PROCEDENCIA del MEDICAMENTO 0:NACIONAL; 1: IMPORTADO:";
cin>>reg.proced;
cout<<"\nregistro modificadoo con exito\n";
fclose(arch);
};
};
getch();
}
//ELIMINACION LOGICA DE REGISTROS DEL ARCHIVO

void farmacia::elilogica(int clave)
{
producto reg;
int res;
res=buscar(clave);
if (res==-1)
else
38
_____________________________________________________________________________
{
if (arch==NULL)
else
{
clrscr();
cout<<"\n===================================================";
"<<reg.estado;
cout<<"\n===================================================";
cout<<"\npresione cualquier tecla para continuar:\n";
getch();
reg.estado=0;
cout<<"\nregistro eliminado exito\n";
fclose(arch);
};
};
getch();
}
// eliminacion fisica de registros
// solo se elimina los registros eliminados en forma logica
void farmacia::elifisica()
{
producto reg;
FILE *ft;
ft=fopen("e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.tmp","wb");
if (arch==NULL || ft==NULL)
else
{
clrscr();
cout<<"\n ELIMINACION FISICA DE REGISTROS\n";
while (!feof(arch))
{
if (reg.estado==1)
fwrite(&reg,sizeof(struct producto),1,ft);
};
cout<<"\nse han copiado satisfactoriamente los registros al archivo temporal\n";
getch();
fclose(arch);
fclose(ft);
char cad[100],cad1[100];
strcpy(cad,"e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.dat");
strcpy(cad1,"e:/jcbv/materia/sis2210/sis2210prog/archivosc++/medicina.tmp");
39
_____________________________________________________________________________
remove(cad);
rename(cad1,cad);
};
}
//reporte de un registro especifico

void farmacia::reporteesp(int clave)
{
producto reg;
int res;
res=buscar(clave);
if (res==-1)
else
{
if (arch==NULL)
else
{
clrscr();
cout<<"\n===================================================";
"<<reg.estado;
cout<<"\n===================================================";
cout<<"\npresione cualquier tecla para continuar\n";
fclose(arch);
};
};
getch();
}
//restauracion de registros eliminados en forma logica
void farmacia::restaurar(int clave)
{
producto reg;
int res;
res=buscar(clave);
if (res==-1)
else
{
if (arch==NULL)
else
{
clrscr();
40
_____________________________________________________________________________
cout<<"\n===================================================";
"<<reg.estado;
cout<<"\n===================================================";
reg.estado=1;
cout<<"\nregistro restaurado con exito\n";
fclose(arch);
};
};
getch();
}
c) Implantación del programa: ‘prueba.cpp’
#include <stdio.h>
#include <conio.h>
#include <e:/jcbv/materia/sis2210/sis2210prog/archivosc++/farmacia.cpp>
int main()
{
farmacia f;
int op,clave;
do {
clrscr();
cout<<"\n PROCEAMIENTO DE ARCHIVOS DIRECTOS";
cout<<"\n ======================================";
cout<<"\n 1: CREACION DEL ARCHIVO VACIO";
cout<<"\n 2: ADICION DE REGISTROS";
cout<<"\n 3: REPORTE GENERAL DE REGISTROS ACTIVOS";
cout<<"\n 4: REPORTE DE REGISTROS INACTIVOS";
cout<<"\n 5: REPORTE DE UN REGISTRO ESPECIFICO";
cout<<"\n 6: MODIFICACION DE REGISTROS";
cout<<"\n 7: ELIMINACION LOGICA";
cout<<"\n 8: ELIMINACION FISICA !!!!!";
cout<<"\n 9: RESTAURAR REGISTROS";
cout<<"\n 10: SALIR DE LA APLICACION";
cout<<"\n ======================================";
cout<<"\n ELIJA LA TAREA A REALIZAR : ";
cin>>op;
switch (op)
{
case 1: f.crear();break;
case 2: f.adicion();break;
case 3: f.reporte();break;
case 4: f.reportei();break;
case 5: clrscr();
cout<<"\ncodigo del medicamento:";
cin>>clave;
f.reporteesp(clave);
break;
case 6: clrscr();
cout<<"\ncodigo del medicamento a modificar:";
41
_____________________________________________________________________________
cin>>clave;
f.modificar(clave);
break;
case 7: clrscr();
cout<<"\ncodigo del medicamento a eliminar:";
cin>>clave;
f.elilogica(clave);
break;
case 8: clrscr();
f.elifisica();
break;
case 9: clrscr();
cout<<"\ncodigo del medicamento a RESTAURAR:";
cin>>clave;
f.restaurar(clave);
break;
};
} while (op<10);
return 0;
}
4. Salida de la ejecución del programa.
42
_____________________________________________________________________________
43
_____________________________________________________________________________
BIBLIOGRAFIA
[1] DEITEL/DEITEL, COMO PROGRAMAR EN C/C++

[2] FCO. JAVIER CEBALLOS SIERRA, CURSO DE PROGRAMACION C/C++
[3] LUIS JOYANES AGUILAR, FUNDAMENTOS DE PROGRAMACION.
[4] LUIS JOYANES AGUILAR, PROGRAMACION ORIENTADA A OBJETOS.
44
_____________________________________________________________________________

Texto Parte II PDF

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Texto Parte II PDF

Cargado por

Copyright:

Formatos disponibles

Metodología de la Programación

PUNTEROS Y ESTRUCTURAS DINÁMICAS DE DATOS ..........................................................................3

2.6.5. CONOCER LA POSICION ACTUAL DEL PUNTERO DE L/E. .........................................................30

PUNTEROS Y ESTRUCTURAS DINÁMICAS DE DATOS

Un puntero es una variable que contiene la dirección de memoria de un dato o de otra

1.1. OPERADORES PARA EL MANEJO DE PUNTEROS.

1.1.1. OPERADOR DE DIRECCION ‘&’.

Es un operador unitario que se aplica a una variable o a objetos como un elemento de un

1.1.2 OPERADOR DE INDIRECCION O CONTENIDO ‘*’.

El resultado del operador ‘*’ es el contenido de la dirección de memoria (variable puntero)

*pt da como resultado el valor o contenido de la dirección de memoria de

1.2. DECLARACIÓN DE PUNTEROS.

Un puntero se declara anteponiendo al identificador que nombra al puntero, el modificador

a es una variable entera

float *pf; //pf es un puntero a un real

El espacio de memoria requerido para un puntero, es el número de bytes necesarios para

1.2.1. ALMACENAMIENTO EN UNA VARIABLE PUNTERO.

En una variable punero se puede almacenar los siguientes valores:

Lo normal es almacenar direcciones de memoria de objetos que se emplea en el programa y

b) CONSTANTE NULL (PUNTERO NULO)

c) VALOR CERO (0).

Mostrando la siguiente salida:

1.3. OPERACIONES CON PUNTEROS.

int a=5, *p,*q;

En este ejemplo, la variable puntero p recupera la dirección de memoria de ‘a’, es

No es posible asignar dos variables puntero si no apuntan al mismo tipo de objeto, el

‘pt’ apunta a nulo, es decir, apunta a nada.

No es posible comparar dos variables puntero que apuntan a objetos diferentes,

1.3.3. ARITMETICA CON PUNTEROS.

Si ‘p’ es un puntero a entero, entonces almacena una dirección de memoria donde se

Si ‘p’ es un puntero a entero, entonces almacena una dirección de memoria donde se

En términos generales, si a un puntero se le Incrementa/Decrementa 1 (uno), entonces el

1.4. PUNTEROS Y ARREGLOS.

El nombre de un arreglo representa la dirección de memoria donde empieza el arreglo en la

El siguiente programa ilustra el procesamiento de la información de un arreglo

Produciendo la siguiente salida:

La función ‘impmat’ muestra el contenido de una matriz de un tamaño de 5 filas y 10

1.4.1. PUNTERO A CADENA DE CARACTERES.

La forma de definir un puntero a una cadena de caracteres es:

El siguiente ejemplo define e inicializa la cadena de caracteres nombre:

1.4.2. PUNTEROS A ESTRUCTURAS.

En un puntero se puede almacenar la dirección de memoria de cualquier tipo de dato, sea

struct persona *pp;

donde ‘pp’ es un puntero a estructura tipo persona.

struct fecha *pf;

Donde ‘pf’ es un puntero a estructura fecha.

pp->ci; hace referencia al campo `ci’ de la estructura persona.

El siguiente programa muestra la declaración de una estructura fecha y un puntero a esa

void leer(struct fecha *f)

La salida del programa anterior es:

1.5. ESTRUCTURAS DINÁMICAS DE DATOS. LISTAS SIMPLES.

Una de las aplicaciones más interesantes y potentes de la memoria dinámica y los

En muchas ocasiones se necesitan estructuras que puedan cambiar de tamaño durante la

Una lista simple abierta tiene la siguiente forma:

Una lista encadena simple es un conjunto finito de elementos autoreferenciados llamados

 Existe un puntero ‘raiz’ que almacena la dirección del primer nodo.

Un nodo tiene dos campos: para el almacenamiento de la información (info) y para el

La lista existe a partir de la variable puntero llamada ‘raiz:

RaízNULL lista vacía.

1.5.1. OPERACIONES BASICAS EN UNA LISTA SIMPLE.

En una lista simple se puede realizar las siguientes operaciones básicas:

 Creación: Normalmente la lista se crea vacía.

int a=5, p,q;