Professional Documents
Culture Documents
orientada a objetos
Prof. J. Refugio Esparza Reyes
Archivos de datos:......................................3
Libreras devC++:......................................9
Numeros Aleatorios en devC++:..............11
Manejo de Estructuras:............................12
Referencias..............................................17
Archivos de datos:
Estructura de Datos: Archivos
Campo
Es un conjunto de caracteres capaz de suministrar una determinada informacin referida
a un concepto. Al igual que en las variables, al definir un campo hay que indicar
claramente sus tres caractersticas:
Nombre: identifica a ese conjunto de caracteres
Tipo: tipo de caracteres que puede contener (alfabtico, entero, etc.-)
Tamao: Cantidad de caracteres que puede contener Por ejemplo, si tenemos que definir
al campo nmero de documento resultara:
Nombre: documento
Tipo: numrico
Tamao: 8 enteros Un campo es la entidad lgica ms pequea, consiste en un conjunto
de byte que conforman un dato. Un campo es la unidad mnima de informacin de un
registro
Almacenamiento permanente
Manipulacin de un gran nmero de datos
Independencia de los programas
Residentes en soportes externos
Estructura
Archivos = Coleccin de Registros
Registros = Coleccin de campos (tamao, longitud,...)
Clave-Un campo que identifica al registro
Archivo: Concepto
Para poder acceder a determinada informacin en cualquier momento, se necesitar que
ella est depositada en soportes fsicos los cuales la almacenan en forma permanente.
Este es el caso de la memoria externa o auxiliar como ser disquete, disco duro, cinta
magntica, etc., En las cuales sin necesidad de estar conectadas a la corriente elctrica,
la informacin permanece all. La forma de guardar los datos en estos dispositivos
auxiliares es mediante unas estructuras llamadas archivos o ficheros.
ARCHIVOS DE DATOS
ARCHIVOS DE PROGRAMA
archivo = open(nombre)
Una vez que los datos han sido ledos del archivo, hay que cerrarlo:
archivo.close()
archivo = open('himno.txt')
for linea in archivo:
print linea[0]
archivo.close()
El ciclo for es ejecutado cuatro veces, una por cada lnea del archivo. La
salida del programa es:
Pept
archivo = open('himno.txt')
for linea in archivo:
print len(linea)
archivo.close()
La salida es:
11
20
13
19
+---+---+---+---+---+---+---+---+---+---+---+
| P | u | r | o | | C | h | i | l | e | \n| = 11 smbolos
+---+---+---+---+---+---+---+---+---+---+---+
Para obtener el string sin el salto de lnea, se puede usar el mtodo strip,
que elimina todos los smbolos de espaciado al principio y al final del
string:
>>> s = ' Hola\n'
>>> s.strip()
'Hola'
archivo = open('himno.txt')
for linea in archivo:
print len(linea.strip())
archivo.close()
10
19
12
18
Lo importante es comprender que los archivos son ledos lnea por lnea
usando el ciclo for.
Escritura en archivos
Los ejemplos anteriores suponen que el archivo por leer existe, y est
listo para ser abierto y ledo. Ahora veremos cmo crear los archivos y
cmo escribir datos en ellos, para que otro programa despus pueda
abrirlos y leerlos.
Hola mundo.
a = open('himno.txt', 'w')
a.write('Puro Chile\n')
a.write('es tu cielo azulado\n')
a.write('puras brisas\n')
a.write('te cruzan tambin.\n')
a.close()
Adems del modo 'w' (write), tambin existe el modo 'a' (append), que
permite escribir datos al final de un archivo existente. Por ejemplo, el
siguiente programa abre el archivo prueba.txt que creamos ms arriba,
y agrega ms texto al final de l:
a = open('prueba.txt', 'a')
a.write('\n')
a.write('Chao ')
a.write('pescao.')
a.close()
Hola mundo.
Chao pescao.
De haber abierto el archivo en modo 'w' en vez de 'a', el contenido
anterior (la frase Hola mundo) se habra borrado.
Yayita Vinagre 39 49 58 55
Perico:Los Palotes:90:75:38:65
Yayita:Vinagre:39:49:58:55
Fulanita:De Tal:96:100:36:71
El formato de estos archivos se suele llamar CSV, que en ingls son las
siglas de comma-separated values (significa valores separados por
comas, aunque tcnicamente el separador puede ser cualquier
smbolo). A pesar del nombre especial que reciben, los archivos CSV son
archivos de texto como cualquier otro, y se pueden tratar como tales.
'Perico:Los Palotes:90:75:38:65\n'
>>> linea.strip().split(':')
['Perico', 'Los Palotes', '90', '75', '38', '65']
Como se trata de un archivo de texto, todos los valores son strings. Una
manera de convertir los valores a sus tipos apropiados es hacerlo uno
por uno:
valores = linea.strip().split(':')
nombre = valores[0]
apellido = valores[1]
nota1 = int(valores[2])
nota2 = int(valores[3])
nota3 = int(valores[4])
nota4 = int(valores[5])
valores = linea.strip().split(':')
nombre, apellido = valores[0:2]
nota1, nota2, nota3, nota4 = map(int, valores[2:6])
O podramos dejar las notas en una lista, en vez de usar cuatro variables
diferentes:
archivo_alumnos = open('alumnos.txt')
for linea in archivo_alumnos:
valores = linea.strip().split(':')
nombre, apellido = valores[0:2]
notas = map(int, valores[2:6])
promedio = sum(notas) / 4.0
print '{0} obtuvo promedio {1}'.format(nombre, promedio)
archivo_alumnos.close()
Para escribir los datos en un archivo, hay que hacer el proceso inverso:
convertir todos los datos al tipo string, pegarlos en un nico string,
agregar el salto de lnea al final y escribir la lnea en el archivo.
Libreras devC++:
fstream:
Flujos hacia/desde ficheros. Permite la manipulacin de archivos desde
el programar, tanto leer como escribir en ellos.
iosfwd:
Contiene declaraciones adelantadas de todas las plantillas de flujos y
sus typedefs estndar. Por ejemplo ostream.
iostream:
Parte del a STL que contiene los algoritmos estndar, es quiz la ms
usada e importante (aunque no indispensable).
La biblioteca list:
Parte de la STL relativa a contenedores tipo list; listas doblemente
enlazadas
math:
Contiene los prototipos de las funciones y otras definiciones para el uso
y manipulacin de funciones matemticas.
memory:
Utilidades relativas a la gestin de memoria, incluyendo asignadores y
punteros inteligentes (auto_ptr).
"auto_ptr" es una clase que conforma la librera memory y permite un
fcil manejo de punteros y su destruccin automticamente.
Biblioteca new:
Manejo de memoria dinmica
numeric:
Parte de la librera numrica de la STL relativa a operaciones numricas.
ostream:
Algoritmos estndar para los flujos de salida.
queue:
Parte de la STL relativa a contenedores tipo queue (colas de objetos).
Librera stdio:
Contiene los prototipos de las funciones, macros, y tipos para manipular
datos de entrada y salida
Librera stdlib:
Contiene los prototipos de las funciones, macros, y tipos para utilidades
de uso general.
string:
Parte de la STL relativa a contenedores tipo string; una generalizacin de
las cadenas alfanumricas para albergar cadenas de objetos. Muy til
para el fcil uso de las cadenas de caracteres, pues elimina muchas de
las dificultades que generan los char
typeinfo:
Mecanismo de identificacin de tipos en tiempo de ejecucin
vector:
Parte de la STL relativa a los contenedores tipo vector; una
generalizacin de las matrices unidimensionales C/C++
forward_list
Esta librera es til para implementar con gran facilidad listas enlazadas
simples.
list
Permite implementar listas doblemente enlzadas (listas enlazadas
dobles) facilmente.
iterator
Proporciona un conjunto de clases para iterar elementos.
regex
Proporciona fcil acceso al uso de expresiones regulares para la
comparacin de patrones.
thread
til para trabajar programacin multihilos y crear mltiples hilos en
nuestra aplicacin.
#define NUM_ELEM 16
int main(void)
{
int i;
srand((unsigned) time(NULL));
printf("Test: ");
return EXIT_SUCCESS;
}
Manejo de Estructuras:
Las estructuras pueden referenciarse completas, usando su nombre,
como hacemos con los objetos que ya conocemos, y tambin se puede
acceder a los elementos definidos en el interior de la estructura, usando
el operador de seleccin (.), un punto. Una vez definida una estructura,
es decir, si hemos especificado un nombre para ella, se puede usar igual
que cualquier otro tipo de C++. Esto significa que se pueden declarar
ms objetos del tipo de estructura en cualquier parte del programa. Para
ello usaremos la forma normal de declaracin de objetos, es decir:
[,<objeto_estructura>...];
struct Persona {
char Nombre[65];
char Direccion[65];
int AnyoNacimiento;
} Fulanito;
En contra de lo que ocurre con el resto de los tipos, que estn pre-
definidos en el lenguaje. Por ejemplo, al declarar char ch; ya se sabe
exactamente que cosa es ch, en este caso hay que definir previamente
el tipo. Los tipos estructura se declaran mediante la palabra clave struct.
Sera algo as como:
struct Punto;
struct Punto {
int x; int y;
};
struct Linea {
} c1;
declara Linea como un tipo struct con dos miembros, cada uno de los
cuales es un tipo struct Punto.
struct StA {
int i,j;
} a, a1;
struct StB {
int i,j;
} b;
Iniciar el objeto
Un tercer paso es inicializar dicha variable. Del mismo modo que para
iniciar ch se realizaba una asignacin del tipo: ch = 'x', en este caso se
utiliza la asignacin (anloga a la de matrices):
La segunda lnea declara que st es una estructura de tipo stA; que pst es
un puntero a dicho tipo, y que arst es un array de 10 estructuras tipo
stA. Como se ver a continuacin, es posible incluso declarar estructuras
sin asignar un nombre al tipo correspondiente. Por ejemplo:
Ejemplo
goto s;
...
s: // L.3 Etiqueta
// espacios diferentes
float f;
struct t {
Referencias
http://progra.usm.cl/apunte/materia/archivos.html
http://alvarenga.blogcindario.com/2013/08/00002-librerias-de-dev-c.html
https://docs.google.com/presentation/d/14soy758axdASDzXc8ZvJh21eR4ZvilHOvggVV07
Ngm0/edit
http://html.rincondelvago.com/estructura-de-datos_5.html
https://mx.answers.yahoo.com/question/index?qid=20090201091350AAECOqk