Programacin orientada a objetos

Prof. J. Refugio Esparza Reyes

Cristian Lorenzo Torres Esparza

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

....................................................... 3
......................................................... 9
................................ 11
............................................. 12
................................................................ 17
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:

P e p t

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.

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.

#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.
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)

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