PDF de programación - Archivos

1. Archivos ......................................................... 2
2. Asignación dinámica de memoria .................................. 10
2.1. Operadores new y delete ...................................... 10
3. Asignación de memoria dinámica para arrays. Arrays dinámicos .... 11
4. Diferencias entre un array estático y un array dinámico. ........ 12
5. Plantillas de funciones, funciones genéricas. ................... 16
6. OO .............................................................. 22
6.1. Introducción ................................................. 22
6.2. Clases y objetos ............................................. 23
6.3. Acceso a los miembros de una clase ........................... 25
6.4. Funciones miembro o métodos .................................. 26
7. Encapsulamiento, acceso a miembros de una clase. ................ 27
8. Constructores y destructores .................................... 28
8.1. Constructores ................................................ 28
8.2. Destructores ................................................. 33
9. Ficheros de cabecera y de implementación ........................ 34
10.
Excepciones ................................................... 35
10.1. Manejo de excepciones ...................................... 36
Punteros a objetos ............................................ 45
Clases y Funciones amigas (friend) ............................ 46
12.1. Funciones friend ........................................... 47
12.2. Clases friend .............................................. 51
Puntero this .................................................. 52
Sobrecarga de operadores ...................................... 54
14.1. Sobrecarga de operadores unarios ........................... 55
14.2. Sobrecarga de operadores binarios .......................... 58
14.3. Sobrecarga de operadores lógicos y relacionales ............ 65
Plantillas de clases, clases genéricas ........................ 67
Herencia ...................................................... 68
16.1. Sintaxis ................................................... 68
16.2. tipos de herencia .......................................... 73
16.3. Accesibilidad .............................................. 74

11.
12.

13.
14.

15.
16.

1

1. Archivos

Archivo de cabecera fstream.h

Abrir el archivo para lectura o entrada

ifstream <nombre_lógico>(“<nombre_físico>”);

<nombre_lógico> es el nombre que asociamos al archivo y con el
cual trabajamos en el programa.
<nombre_físico> es la ruta de acceso al archivo. se escribe
entre comillas.

Abrir el archivo para escritura o salida

ofstream <nombre_lógico>(“<nombre_físico>”);
ofstream <nombre_lógico>(“<nombre_físico>”, ios_base::out);

Si el archivo existe, el archivo será sobrescrito.

Abrir el archivo para añadir información al final

ofstream <nombre_lógico>(“<nombre_físico>”, ios_base::app);

Si el archivo no existe, se crea.

Cerrar un fichero.

<nombre_lógico>.close();

Fin de fichero función que nos indica cuando hemos llagado al
final del fichero.

<nombre_lógico>.eof();

Acceso carácter a carácter
get() lee carácter a carácter, del fichero del cual se llama.

<nombre_lógico>.get(variable char)

put() escribe carácter a carácter lo que se pase por parámetro

<nombre_lógico>.put(variable char)

2

Ejercicio: Haz un programa que muestra por pantalla el contenido
del fichero "c:\\datos.txt" numerando las líneas

#include <fstream.h>
void main( )
{

char c;
ifstream archivo("c:\\datos.txt");
int conta=0;
while (!archivo.eof())
{

conta++;
cout<<conta<<": ";

archivo.get(c);

while ((c!='\n') && (!archivo.eof()))
{

cout<<c;

archivo.get(c);

}
cout<<endl;

}

archivo.close( );

}

Fichero datos.txt

Esto es
una prueba

Adios.

Salida con el compilador Microsoft Visual C++ 6.0 y con el compilador
turbo C++ 1.01 de Borland

1: Esto es
2: una prueba
3:
4: Adios.

Si el fichero está vacío la salida es

1:

3

//Otra forma

#include <fstream.h>
void main( )
{

char c;
ifstream archivo("c:\\datos.txt");
int conta=1;
cout<<conta<<": ";
while (!archivo.eof())
{

archivo.get(c);

while (c=='\n')
{

cout<<c;

conta++;
cout<<conta<<": ";
archivo.get(c);

}

cout<<c;

}
archivo.close( );

}

4

Ejercicio:
Haz un programa que lea de un fichero y escribe en dos ficheros
alternativamente las palabras de este fichero.

c:\datos.txt
Esto es una prueba
Adios.

Esto una Adios.
c:\impares.txt

es prueba
c:\pares.txt

#include <fstream.h>
#include <conio.h>
void main( )
{

char c;
ifstream archivo("c:\\datos.txt");
ofstream fpares("c:\\pares.txt");
ofstream fimpares("c:\\impares.txt");

archivo.get(c);
while (!archivo.eof())
{

while ((c != ' ') && (c !='\n') && (!archivo.eof()))
{

fimpares.put(c);
archivo.get(c);
}

while (((c == ' ') || (c =='\n')) && (!archivo.eof()))
{

fimpares.put(c);
archivo.get(c);

}

while ((c != ' ') && (c !='\n') && (!archivo.eof()))
{

fpares.put(c);
archivo.get(c);
}

while (((c == ' ') || (c =='\n')) && (!archivo.eof()))
{

fpares.put(c);
archivo.get(c);

}

} //while
archivo.close();
fpares.close();
fimpares.close();

} //main

Si el fichero de entrada está vacío, los ficheros de salida estarán
vacíos.

5

Acceso palabra a palabra

Se puede acceder palabra a palabra mediante los operados <<, >>

Ejercicio:
Leer
pantalla, cada palabra en una línea.

c:\datos.txt

del

archivo

todas

las

palabras

mostrando

por

#include <fstream.h>
void main( )
{

ifstream archivo("c:\\Datos.txt");
char palabra[80]="";
archivo >> palabra;
if (archivo.eof())

cout << "archivo vacio";

else
{

<< palabra << endl;

cout
while (!archivo.eof( ))
{

archivo >> palabra;
cout

<< palabra << endl;

};

}

archivo.close( );

}

c:\\Datos.txt

Pantalla

Esto es una
prueba
Adios

Esto
es
una
prueba
Adios

Con el archivo de entrada vacío sale por pantalla

archivo vacio

6

Otra forma es

#include <fstream.h>
void main( )
{

ifstream archivo("c:\\Datos.txt");
char palabra[80]="";

while (!archivo.eof( ))
{

archivo >> palabra;
cout

<< palabra << endl;

};

archivo.close( );

}

Ejericio: Verificar que ocurre en estos ejemplos si el fichero de
entrada termina con varios saltos de línea, modificar el código
convenientemente.

7

A veces conviene leer de línea en línea, para ello podemos utilizar la
función getline()

Ejercicio: Haz un programa que muestra por pantalla el contenido del
fichero "c:\\datos.txt" numerando las líneas

#include <fstream.h>
void main( )
{

char c[80];
int conta=1;
ifstream archivo("c:\\datos.txt");
archivo.getline(c,79);
if (archivo.eof())

cout << "archivo vacio";

else

cout<< conta<<": " <<c << endl;
while (!archivo.eof())

{

conta++;

cout<<conta<<": ";

archivo.getline(c,79);
cout<< c << endl;

}

archivo.close( );

{

}

}

El fichero de entrada contiene el texto:

Esto es
una prueba
Adios.

La salida por pantalla es:

En el compilador Microsoft Visual C++ 6.0

1: Esto es
2: una prueba
3: Adios.

y en el compilador turbo C++ 1.01 de Borland

1: Esto es

2: una prueba

3: Adios.

Observación: nótese que este último compilador hace dos saltos de
línea seguidos.

8

Ejercicio

Haz un programa que lea de dos ficheros y escriba en otro fichero
alternativamente las palabras de estos dos ficheros. Los ficheros de
entrada tienen las palabras separadas por un único espacio en blanco o
un salto de línea
Utilizar la lectura/escritura de palabras con los operadores << >>

9

2. Asignación dinámica de memoria

Cuando declaramos variables locales o globales, el espacio de
almacenamiento se reserva en tiempo de compilación. C++ ofrece
los operadores new y delete para gestionar la memoria
dinámicamente, es decir , para asignar o liberar espacio
dinámicamente. Se quiere gestionar la memoria cuando a priori no
sé cuantos elementos voy a tener.

2.1.

Operadores new y delete

New asigna memoria y devuelve un puntero, que es la dirección
del bloque asignado de memoria.

Tipo *puntero = new tipo

//No arrays

Ej

int *pint

= new int;

//no array

Inicialización de memoria con un valor

Cuando se asigna memoria con el operador new, se puede

inicializar con el valor que se pasa entre paréntesis detrás de
la declaración.

int pint = new int (14);

//

*pitn=14;

Si no hay suficiente memoria disponible, el operador new
devuelve un puntero NULL

Delete elimina la memoria asignada dinámicamente por new

delete puntero;

Ej

int *pint
delete pint;

= new int;

//no array

10

3. Asignación de memoria dinámica para arrays.

Arrays dinámicos

Se pueden asignar arrays usando new.

tipo *puntero = new tipo[dimensiones]
delete [] puntero;

//Arrays

int *pint = new int[300]
delete [] pint;

//array

11

4. Diferencias entre un array estático y un array

dinámico.

int m[20];

// array estático se crea en tiempo de compilación;
// su memoria permanece asignada
// durante toda la ejecución del programa.

int *m = new int [20];

// array dinámico, se crea en tiempo de ejecución; su
// memoria se asigna sólo cuando
//
// libera cuando se invoca al operador delete

se ejecuta su declaración, y se

Ej:

// asignación dinámica de un entero.
#include<iostream.h>
int main()
{

int *p;
p = new int;

if (p==NULL)
{

//int *p = new int;

// if (!p)

cout << "memoria insuficiente" ;
return 1;

}
*p = 2345;
cout << *p;
delete p;
return 0;

} //main

Se muestra: 2345

12

// asignación dinámica de un array.
Ej:

#include <iostream.h>

void main()
{
int x;
cout << "Introduce el número de elementos";
cin >> x;
if (x < 0)

{cout << "error";
return;
}

int *p = new int[x];
for (int i=0; i < x; i++)

{cout << "elemento " << i << " ";
cin >> p[i];

cout << endl;

}

for (int j=0; j < x; j++)

cout << "elemento " << j << " es: " << p[j] << endl;

delete [] p;
}

Observación: en el compilador Microsoft Visual 6.0 este código es
válido, sin embargo, en el compilador Borland turbo C++ 1.01 hay que
cambiar la sentencia

por

delete [] p;

delete p;

13

Ejercicio: haz un programa que lea de teclado nombre, apellido y edad
de todos los alumnos de una clase, lo guarde dinámicamente, or