You are on page 1of 19

Programacin

orientada a objetos
Prof. J. Refugio Esparza Reyes

Miguel Angel Carreon Martinez


Especialidad: informtica
Grupo: 409
Docente: Navarrete Beas Yolanda Catalina
24/03/2017
INDICE

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

Para leer datos de un archivo, hay que abrirlo de la siguiente manera:

archivo = open(nombre)

nombre es un string que tiene el nombre del archivo. archivo es el


archivo lgico a travs del que se manipular el archivo.

Si el archivo no existe, ocurrir un error de entrada y salida (IOError).

Es importante recordar que la variable archivo es una representacin


abstracta del archivo, y no los contenidos del mismo.

La manera ms simple de leer el contenido es hacerlo lnea por lnea.


Para esto, basta con poner el archivo lgico en un ciclo for:

for linea in archivo:


# hacer algo

Una vez que los datos han sido ledos del archivo, hay que cerrarlo:

archivo.close()

Por ejemplo, supongamos que tenemos el archivo himno.txt que tiene el


siguiente contenido:

Puro Chile es tu cielo azulado puras brisas te cruzan tambin.


El archivo tiene cuatro lneas. Cada lnea termina con un salto de lnea
(\n), que indica que a continuacin comienza una lnea nueva.

El siguiente programa imprime la primera letra de cada lnea del himno:

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

Otro ejemplo: el siguiente programa imprime cuntos smbolos hay en


cada lnea:

archivo = open('himno.txt')
for linea in archivo:
print len(linea)
archivo.close()

La salida es:

11
20
13
19

Note que el salto de lnea (el enter) es considerado en la cuenta:

+---+---+---+---+---+---+---+---+---+---+---+
| 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'

Si modificamos el programa para eliminar el salto de lnea:

archivo = open('himno.txt')
for linea in archivo:
print len(linea.strip())
archivo.close()

Entonces la salida es:

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.

Uno puede crear un archivo vaco abrindolo de la siguiente manera:

archivo = open(nombre, 'w')

El segundo parmetro de las funciones open indica el uso que se le dar


al archivo. 'w' significa escribir (write en ingls).

Si el archivo sealado no existe, entonces ser creado. Si ya existe,


entonces ser sobreescrito. Hay que tener cuidado entonces, pues esta
operacin elimina los datos del archivo que exista previamente.

Una vez abierto el archivo, uno puede escribir datos en l usando el


mtodo write:
a = open('prueba.txt', 'w')
a.write('Hola ')
a.write('mundo.')
a.close()

Una vez ejecutado este programa, el archivo prueba.txt ser creado (o


sobrescrito, si ya exista). Al abrirlo en el Bloc de Notas, veremos este
contenido:

Hola mundo.

Para escribir varias lneas en el archivo, es necesario agregar


explcitamente los saltos de lnea en cada string que sea escrito. Por
ejemplo, para crear el archivo himno.txt que usamos ms arriba,
podemos hacerlo as:

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()

Si abrimos el archivo prueba.txt en el Bloc de Notas, veremos esto:

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.

Archivos de valores con separadores

Una manera usual de almacenar datos con estructura de tabla en un


archivo es la siguiente: cada lnea del archivo representa una fila de la
tabla, y los datos de una fila se ponen separados por algn smbolo
especial.

Por ejemplo, supongamos que queremos guardar en un archivo los datos


de esta tabla:

Nombre Apellido Nota 1 Nota 2 Nota 3 Nota 4

Perico Los Palotes 90 75 38 65

Yayita Vinagre 39 49 58 55

Fulana De Tal 96 100 36 71

Si usamos el smbolo: como separador, el archivo, que


llamaremos alumnos.txt, debera quedar as:

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.

Los archivos de valores con separadores son muy fciles de leer y


escribir, y por esto son muy usados. Como ejemplo prctico, si usted
desea hacer un programa que analice los datos de una hoja de clculo
Excel, puede guardar el archivo con el formato CSV directamente en el
Excel, y luego abrirlo desde su programa escrito en Python.

Para leer los datos de un archivo de valores con separadores, debe


hacerlo lnea por lnea, eliminar el salto de lnea usando el
mtodo strip y luego extraer los valores de la lnea usando el
mtodo split. Por ejemplo, al leer la primera lnea del archivo de ms
arriba obtendremos el siguiente string:

'Perico:Los Palotes:90:75:38:65\n'

Para separar los seis valores, lo podemos hacer as:

>>> 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])

Una manera ms breve es usar las rebanadas y la funcin map:

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:

notas = map(int, valores[2:6])

Por ejemplo, un programa para imprimir el promedio de todos los


alumnos se puede escribir as:

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.

Si los datos de la lnea ya estn en una lista o una tupla, podemos


convertirlos a string usando la funcin map y pegarlos usando el
mtodo join:

alumno = ('Perico', 'Los Palotes', 90, 75, 38, 65)


linea = ':'.join(map(str, alumno)) + '\n'
archivo.write(linea)

Otra manera es armar el string parte por parte:

linea = '{0}:{1}:{2}:{3}:{4}:{5}\n'.format(nombre, apellido,


nota1, nota2, nota3, nota4)
archivo.write(linea)

Como siempre, usted debe preferir la manera que le parezca ms simple


de entender.

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.

Numeros Aleatorios en devC++:


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

#define NUM_ELEM 16

int main(void)
{
int i;
srand((unsigned) time(NULL));

printf("Test: ");

for (i = 0; i < NUM_ELEM; i++){


printf("%d", rand() % NUM_ELEM);
printf(i == NUM_ELEM - 1 ? "\n" : " ");
}

return EXIT_SUCCESS;
}

Ya que esa funcin ya est declarada en el header stdlib.h. Esa funcin


la debes llamar al principio de tu programa, por ejemplo al principio de
la funcin main y solo debes llamarla cuando necesitas generar una
nueva semilla.

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:

[struct] <identificador> <objeto_estructura>

[,<objeto_estructura>...];

En C++ la palabra struct es opcional en la declaracin de objetos, al


contrario de lo que sucede en C, en el que es obligatorio usarla.
Ejemplo:

struct Persona {

char Nombre[65];

char Direccion[65];

int AnyoNacimiento;

} Fulanito;

Este ejemplo define la estructura Persona y declara a Fulanito como un


objeto de ese tipo. Para acceder al nombre de Fulanito, por ejemplo para
visualizarlo, usaremos la forma:

cout << Fulanito.Nombre;

Funciones en el interior de estructuras^

C++, permite incluir funciones en el interior de las estructuras.


Normalmente estas funciones tienen la misin de manipular los datos
incluidos en la estructura, y su uso est muy relacionado con la
programacin orientada a objetos. Aunque esta caracterstica se usa
casi exclusivamente con las clases, como veremos ms adelante,
tambin puede usarse en las estructuras. De hecho, en C++, las
diferencias entre estructuras y clases son muy tenues. Dos funciones
muy particulares son las de inicializacin, o constructor, y el destructor.
Veremos con ms detalle estas funciones cuando asociemos las
estructuras y los punteros. El constructor es una funcin sin tipo de
retorno y con el mismo nombre que la estructura. El destructor tiene la
misma forma, salvo que el nombre va precedido el smbolo "~".

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 Punt2 {int x; int y; int z; };


La primera sentencia es una declaracin incompleta (ver ms abajo); la
segunda es una definicin completa de una nueva clase tipo struct
denominado Punt2; tiene tres componentes perfectamente definidos
(tres int: x, y, z respectivamente).

Ya hemos sealado que en C++ las estructuras son un tipo de clases;


entonces, si nos referimos a la terminologa de la POO diramos que en
esta fase estamos definiendo la clase. El conjunto de declaraciones
dentro de los corchetes {...; ...; ...; } declara los nombres y tipos de sus
miembros. Los miembros pueden ser de cualquier tipo con una
excepcin:

-Un miembro no puede ser la estructura que se declara porque dara


lugar a una declaracin circular (lo definido est dentro de su definicin).
Ejemplo:

struct mystr { mystr s }; // Ilegal

-Uno, o varios, de los miembros puede ser un puntero a la estructura


que se est declarando. Ejemplo:

struct mystr { mystr *ps } // Ok: Correcto

Nota: constituye la base de estructuras auto referenciadas; una tcnica


de programacin que tiene amplias posibilidades de aplicacin. Por
ejemplo, listas enlazadas y rboles

Tambin es posible que los miembros de una estructura sean a su vez


estructuras previamente definidas, dando lugar a estructuras anidadas.
Por ejemplo:

struct Punto {

int x; int y;

};

struct Linea {

struct Punto p1;

struct Punto p2;

} c1;
declara Linea como un tipo struct con dos miembros, cada uno de los
cuales es un tipo struct Punto.

Nota: en C, un miembro no puede ser del tipo "funcin devolviendo...".


Es decir, las funciones no pueden ser miembros de la estructuras C (de
lo contrario seran clases). En cambio, s estn admitidos los "punteros a
funcin devolviendo..." (ya que son variables, no mtodos). Las
estructuras C++ s pueden incluir funciones miembro (de hecho son
clases), adems, en C++ la palabra struct puede omitirse.

rear un objeto (instanciar la clase)

Un segundo paso es declarar una variable como perteneciente al nuevo


tipo. Del mismo modo que para declarar una variable ch como de tipo
char declarbamos: char ch;, en este caso, para declarar una variable st
como estructura tipo punto se utiliza:

struct Punto pt; // C y C++

En C++ no es necesario sealar que Punto es una estructura


(suponemos que ya lo sabe el compilador por las sentencias anteriores),
de forma que si no existe ninguna otra variable punto en el mismo
mbito de nombres, no hay ambigedad y se puede poner directamente:

Punto pt; // C++

Usando la terminologa de la POO diramos que estamos instanciando la


clase, es decir, creando un objeto concreto pt, con espacio en memoria,
que pertenece a (es derivado de) dicha clase. Dichos objetos s pueden
ser asignados con valores concretos en sus miembros.

Advertir que cada declaracin de (tipo de) estructura introduce un nuevo


tipo, distinto de los dems (una nueva clase), de forma que las
declaraciones:

struct StA {

int i,j;

} a, a1;

struct StB {

int i,j;
} b;

Definen dos tipos de estructura distintas: StA y StB; los objetos a y b1


son del tipo StA, pero a y b son de tipo distinto.

Desde la ptica de la POO la frase anterior se enunciara como sigue:


"definen dos clases distintas, StA y StB; los objetos a y b1 son instancias
de StA, pero b lo es de la clase StB. Por tanto, a y b son objetos de tipo
distinto.

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):

st = { 12, 25, 3};

Los pasos 2 y 3 se pueden realizar en la misma sentencia. Por ejemplo:

struct punto st = { 12, 25, 3};

Tambin puede realizarse los tres pasos en una misma sentencia:

struct punto { int x; int y; intz; } p1 = { 12, 25, 3};

Una vez definido el nuevo tipo, pueden declararse punteros y matrices


de estructuras de dicho tipo. Por ejemplo:

struct stA { ... }; // define la estructura tipo stA

struct stA st, *pst, arst[10];

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:

struct { ... } st, *pst, arst[10];

Ejemplo

goto s;
...

s: // L.3 Etiqueta

struct s { // L.4 OK: nombres de tipo_de_estructura y etiqueta en

// espacios diferentes

int s; // L.6 OK: nombres miembro de estructura en espacio privado

float s; // L.7 ILEGAL: nombre de miembro duplicado

} s; // L.8 OK: nombre_de_estructura en espacio diferente de

// nombre de etiqueta (L.3) y de tipo_de_estructura (L4)

// En C++, esto solo es posible si s no tiene un constructor

union s { // L.11 ILEGAL: nombre duplicado con el de tipo s (L.4)

int s; // L.12 OK: nuevo espacio de miembros

float f;

} f; // L.14 OK: espacio diferente que el de miembros (ver L.8)

struct t {

int s; // L.16 OK: nuevo espacio de miembros ...

} s; // L.18 ILEGAL: nombre duplicado con el de estructura s (L8)

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