LECTURAS COMPLEMENTARIAS

LECTURAS COMPLEMENTARIAS
1. Estructuras de Datos
http://cuhwww.upr.clu.edu/~jse/cursos/4097/notas/
2. versión electrónica y en línea de uno de los libros sobre estructuras de
datos de mayor interés (Baeza-Yates).
http://www.dcc.uchile.cl/~rbaeza/handbook/hbook.html
3. Algorithms and Data Structures Research & Reference Material". Muchas
implementaciones, algoritmos y material de referencia
http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/index.html
4. Estructuras arbóreas
http://www.infor.uva.es/~jmrr/TAD2003/home.htm
5. MANUAL DE C++
http://kataix.umag.cl/~mmarin/topinf/cs23/c++/pagina022a.htm
6. Recursividad
http://www.conclase.net/c/curso/index.php?cap=024
http://decsai.ugr.es/~lcv/Docencia/mp2/apuntes/tema3.pdf.
7. Tutorial de estructuras de datos en C++ interactivo
http://decsai.ugr.es/~jfv/ed1/c++/cdrom5/index.htm
8. Metodología de la Programacion II
ARCHIVOS BINARIOS EN C++
//Ejemplo de ficheros de acceso aleatorio.
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdlib>
#include <cstring>
using namespace std;
// Funciones auxiliares:
int Menu();
long LeeNumero();
// Clase registro.
class Registro {
public:
Registro(char *n=NULL, int d1=0, int d2=0, int d3=0, int d4=0) :
valido('S') {
if(n) strcpy(nombre, n); else strcpy(nombre, "");
dato[0] = d1;
dato[1] = d2;
dato[2] = d3;
dato[3] = d4;
}
void Leer();
void Mostrar();
void Listar(long n);
const bool Valido() { return valido == 'S'; }
const char *Nombre() { return nombre; }
private:
char valido; // Campo que indica si el registro es válido
// S->Válido, N->Inválido
char nombre[34];
int dato[4];
};
// Implementaciones de clase Registro:
// Permite que el usuario introduzca un registro por pantalla
void Registro::Leer() {
system("cls");
cout << "Leer registro:" << endl << endl;
valido = 'S';
cout << "Nombre: ";
cin.getline(nombre, 34);
for(int i = 0; i < 4; i++) {
cout << "Dato[" << i << "]: ";
dato[i] = LeeNumero();
}
}
// Muestra un registro en pantalla, si no está marcado como borrado
void Registro::Mostrar()
{
system("cls");
if(Valido()) {
cout << "Nombre: " << nombre << endl;
for(int i = 0; i < 4; i++)
cout << "Dato[" << i << "]: " << dato[i] << endl;
}
cout << "Pulsa una tecla";
cin.get();
}
// Muestra un registro por pantalla en forma de listado,
// si no está marcado como borrado
void Registro::Listar(long n) {
int i;
if(Valido()) {
cout << "[" << setw(6) << n << "] ";
cout << setw(34) << nombre;
for(i = 0; i < 4; i++)
cout << ", " << setw(4) << dato[i];
cout << endl;
}
}
// Clase Datos, almacena y trata los datos.
class Datos :public fstream {
public:
Datos() : fstream("alea.dat", ios::in | ios::out | ios::binary) {
if(!good()) {
open("alea.dat", ios::in | ios::out | ios::trunc | ios::binary);
cout << "fichero creado" << endl;
cin.get();
}
}
~Datos() {
Empaquetar();
}
void Guardar(Registro &reg);
bool Recupera(long n, Registro &reg);
void Borrar(long n);
private:
void Empaquetar();
};
// Implementación de la clase Datos.
void Datos::Guardar(Registro &reg) {
// Insertar al final:
clear();
seekg(0, ios::end);
write(reinterpret_cast<char *> (&reg), sizeof(Registro));
cout << reg.Nombre() << endl;
}
bool Datos::Recupera(long n, Registro &reg) {
clear();
seekg(n*sizeof(Registro), ios::beg);
read(reinterpret_cast<char *> (&reg), sizeof(Registro));
return gcount() > 0;
}
// Marca el registro como borrado:
void Datos::Borrar(long n) {
char marca;
clear();
marca = 'N';
seekg(n*sizeof(Registro), ios::beg);
write(&marca, 1);
}
// Elimina los registros marcados como borrados
void Datos::Empaquetar() {
ofstream ftemp("alea.tmp", ios::out);
Registro reg;
clear();
seekg(0, ios::beg);
do {
read(reinterpret_cast<char *> (&reg), sizeof(Registro));
cout << reg.Nombre() << endl;
if(gcount() > 0 && reg.Valido())
ftemp.write(reinterpret_cast<char *> (&reg), sizeof(Registro));
} while (gcount() > 0);
ftemp.close();
close();
remove("alea.bak");
rename("alea.dat", "alea.bak");
rename("alea.tmp", "alea.dat");
open("alea.dat", ios::in | ios::out | ios::binary);
}
int main()
{
Registro reg;
Datos datos;
int opcion;
long numero;
do {
opcion = Menu();
switch(opcion) {
case '1': // Añadir registro
reg.Leer();
datos.Guardar(reg);
break;
case '2': // Mostrar registro
system("cls");
cout << "Mostrar registro: ";
numero = LeeNumero();
if(datos.Recupera(numero, reg))
reg.Mostrar();
break;
case '3': // Eliminar registro
system("cls");
cout << "Eliminar registro: ";
numero = LeeNumero();
datos.Borrar(numero);
break;
case '4': // Mostrar todo
numero = 0;
system("cls");
cout << "Nombre
Datos" << endl;
while(datos.Recupera(numero, reg)) reg.Listar(numero++);
cout << "pulsa return";
cin.get();
break;
}
} while(opcion != '0');
return 0;
}
// Muestra un menú con las opciones disponibles y captura una opción del
usuario
int Menu()
{
char resp[20];
do {
system("cls");
cout << "MENU PRINCIPAL" << endl;
cout << "--------------" << endl << endl;
cout << "1- Insertar registro" << endl;
cout << "2- Mostrar registro" << endl;
cout << "3- Eliminar registro" << endl;
cout << "4- Mostrar todo" << endl;
cout << "0- Salir" << endl;
cin.getline(resp, 20);
} while(resp[0] < '0' && resp[0] > '4');
return resp[0];
}
// Lee un número suministrado por el usuario
long LeeNumero()
{
char numero[6];
fgets(numero, 6, stdin);
return atoi(numero);
}
Anexo A
Programas
// Programa 1.
Ejemplo de Precedencia
#include <iostream.h>
void main (void)
{
int
iuno, idos, isum;
float
ftres, fdiv;
variables
cout << "\n Teclee el entero uno: ";
cin >> iuno;
// Declaración de
// Lectura del primer entero
cout << "\n Teclee el entero dos: ";
cin >> idos;
cout << "\n Teclee el flotante tres: ";
cin >> ftres;
isum = (int) (iuno + idos + ftres);
cout << "\n La suma de los tres datos es: " << isum;
fdiv = iuno + idos / ftres;
cout << "\n La division es: " << fdiv << endl;
}
// Programa 3.
Ejemplo Operadores de relación y lógicos
#include <iostream.h>
void main (void)
int
{
iuno, idos, itres;
cout << "\n Teclee el primer entero: " ;
cin >> iuno;
cout << "\n Teclee el segundo entero: " ;
cin >> idos;
cout << "\n Teclee el tercer entero: " ;
cin >> itres;
if (( iuno >= idos ) && ( itres <= iuno ))
cout << "\n El numero mayor es: " << iuno << endl;
else {
idos += itres;
// Suma
itres--;
// Decremento
cout << "\n Entero dos: " << idos << ", entero tres: " << itres
<< endl;
}
}
// Programa 4.
Ejemplo switch
#include <iostream.h>
int main(void)
int in;
{
cout << "\n Teclee el dígito decimal a convertir: ";
cin >> in;
cout << endl;
if ((in < 0) || (in > 15)) {
cout << " \n *** ERROR en el dígito de entrada *** " << endl;
return 1;
}
else {
cout << "\n La conversión a hexadecimal es: ";
switch (in) {
case 0: case 1: case 2: case 3: case 4:
case 5: case 6: case 7: case 8: case 9:
cout << in << endl;
break;
case 10:
cout << 'A' << endl;
break;
case 11:
cout << 'B' << endl;
break;
case 12:
cout << 'C' << endl;
break;
case 13:
cout << 'D' << endl;
break;
•
•
default:
cout << "*** ERROR ***" << endl;
}
}
return 0;
}
// Programa 5.
Ejemplo while
#include <iostream.h>
int main(void)
{
int in, otro = 1;
while (otro) {
otro = 0;
cout << "\n Teclee el dígito decimal a convertir: ";
cin >> in;
if ((in < 0) || (in > 15)) {
cout << " \n *** ERROR en el dígito de entrada *** " << endl;
otro = 1;
}
else {
cout << " \n La conversión a hexadecimal es: ";
switch (in) {
case 0: case 1: case 2: case 3: case 4:
case 5: case 6: case 7: case 8: case 9:
cout << in << endl;
break;
case 10:
cout << 'A' << endl;
break;
case 11:
cout << 'B' << endl;
break;
•
•
•
default:
cout << "*** ERROR ***" << endl;
otro = 1;
}
}
}
return 0;
}
// Programa 6.
Ejemplo for
#include <iostream.h>
int main(void)
{
int x;
cout << "\n ¿Sucesión Fibonacci de? ";
cin >> x;
if ( x == 0 || x == 1)
cout << "Fib(" << x << ")= " << x << endl;
else
{
unsigned long
int j = x-1;
t0 = 0, t1 = 1, sum = 0;
for (int i=0; i<j; i++)
sum=t0+t1;
t0=t1;
t1=sum;
}
{
cout << "Fib(" << x << ")= " << sum << endl;
}
return 0;
}
/* Programa 7.
Programa con funciones */
#include <iostream.h>
double elevar_cuadrado(double);
Prototipo
void main(void)
//
{
int num;
cout << " \n Numero a elevar al cuadrado: ";
cin >> num;
cout << endl;
cout << " \n El cuadrado de " << num << " es "
<< elevar_cuadrado(num)
función
<< endl;
}
double elevar_cuadrado(double x)
la función
{
return x*x;
}
// Llamada a la
// Definición de
/* Programa 8.
Ejemplo de alcances */
#include <iostream.h>
void a (void);
void b (void);
void c (void);
int x = 1;
main( )
// Prototipos de funciones
// variable global
{
int x = 5;
// variable local de main
cout << "Variable local x en el alcance externo de main es " <<
x << endl;
{
// empieza nuevo alcance
int x = 7;
cout << "Variable local x en el alcance interno de main es
" << x << endl;
}
// termina nuevo alcance
cout << "Variable local x en el alcance externo de main es " <<
x << endl;
a ( );
// a tiene una variable local
x
b ( );
estática x
c ( );
global x
a ( );
local x
b ( );
mantiene su valor
c ( );
también retiene su valor
// b tiene una variable local
// c utiliza la variable
// a reinicializa la variable
// la variable estática x
// la variable global x
cout << "Variable local x en la función main es " << x << endl;
return 0;
}
void a (void)
{
int x = 25;
cout << endl << "Variable local x en a es " << x << " después de
entrar a a \n";
++x;
cout << "Variable local x en a es " << x << " antes de salir de
a" << endl;
}
void b (void)
{
static int x = 50;
primera vez que
// inicialización estática (sólo la
// se llama a b
cout << endl << "Variable estática local x es " << x << " al
entrar a b" << endl;
++x;
cout << "Variable estática local x es " << x << " al salir de b"
<< endl;
}
void c (void)
{
cout << endl << "Variable global x es " << x << " al entrar a c"
<< endl;
x *= 10;
cout << "Variable global x es " << x << " al salir de c" <<
endl;
}
/* Programa 9.
Funciones sin argumentos */
#include <iostream.h>
void f1( );
void f2 (void);
main ( )
{
f1 ( );
f2 ( );
return 0;
}
void f1 ( )
{
cout << "La función f1 no recibe argumentos" << endl;
}
void f2 ( )
{
cout << "La función f2 tampoco recibe argumentos" << endl;
}
/* Programa 10.
referencia */
Comparación de llamada por valor y llamada por
#include <iostream.h>
int squareByValue ( int );
void squareByReference ( int & );
void main ( )
{
int x = 2, z = 4;
cout << "x = " << x << " antes de squareByValue " << endl
<< " Valor regresado por squareByValue: "
<< squareByValue ( x ) << endl
<< "x = " << x << " después de squareByValue" << endl << endl;
cout << "z = " << z << " antes de squareByReference " << endl;
squareByReference ( z );
cout << "z = " << z << " después de squareByReference" << endl << endl;
}
int squareByValue ( int a )
{
return a *= a;
no se
// argumento del que llama
// modifica
}
void squareByReference ( int &cRef )
{
cRef *= cRef;
}
// argumento del que llama se modifica
/* Programa 11.
Utilizando el operador de resolución de alcance unario */
#include <iostream.h>
float value = 1.2345;
main ( )
{
int value = 7;
cout
<< " Valor local
= " << value << end
<< " Valor global = " << ::value << endl;
return 0;
}
/* Programa 12.
Utilizando function overloading /*
#include <iostream.h>
int square (int x)
{ return x *x; }
double square (double y)
{ return y * y; }
main ( )
{
cout << "El cuadrado del número entero
7 es "
<< square ( 7 ) << endl
<< "El cuadrado del número real
<< square ( 7.5 ) << endl;
return 0;
}
7.5 es "
/* Programa 13.
Utilizando Templates */
#include <iostream.h>
template <class T>
T
{
maximum ( T value1, T value2, T value3 )
T
max = value1;
if ( value2 > max )
max = value2;
if ( value3 > max )
max = value3;
return max;
}
main ( )
{
int
int1, int2, int3;
cout << " Teclea tres enteros: " ;
cin >> int1 >> int2 >> int3;
cout << " El mayor de los tres enteros es: "
<< maximum ( int1, int2, int3 );
enteros
// versión de
double double1, double2, double3;
cout << endl << " Teclea tres dobles: " ;
cin >> double1 >> double2 >> double3;
cout << " El mayor de los tres dobles es: "
<< maximum ( double1, double2, double3 );
// versión de
dobles
char char1, char2, char3;
cout << endl << " Teclea tres caracteres:
cin >> char1 >> char2 >> char3;
" ;
cout << " El mayor de los tres caracteres es: "
<< maximum ( char1, char2, char3 ) << endl;
caracteres
return 0;
}
// versión de
/* Programa 14.
Inicializando un arreglo */
#include <iostream.h>
#include <iomanip.h>
main ( )
{
int
n[10];
for ( int i = 0; i < 10; i++ )
arreglo
n[i] = 0;
//
inicializando
cout << "Elemento " << setw ( 13 ) << "Valor " << endl;
for ( i = 0; i < 10; i ++)
cout << setw ( 8 ) << i << setw ( 13 ) << n[i] << endl;
return 0;
}
el
/* Programa 15.
20 */
Inicializando el arreglo s con los números pares del 2 al
#include <iostream.h>
#include <iomanip.h>
main ( )
{
const int tamaño_arreglo = 10;
int s [ tamaño_arreglo ];
for ( int j = 0; j < tamaño_arreglo; j++ )
s [ j ] = 2 + 2 * j;
cout << "Elemento" << setw ( 13 ) << "Valor" << endl;
for ( j = 0; j < tamaño_arreglo; j++ )
cout << setw ( 8 ) << j << setw ( 13 ) << s [ j ] << endl;
return 0;
}
/* Programa 16.
Arreglos estáticos y automáticos */
#include <iostream.h>
void staticArrayInit (void);
void automaticArrayInit (void);
void main ( ) {
cout << "Primera llamada a cada función : " << endl;
staticArrayInit ( );
automaticArrayInit ( );
cout << endl << endl << "Segunda llamada a cada función : " << endl;
staticArrayInit ( );
automaticArrayInit ( );
}
void staticArrayInit (void)
estático
// Función que muestra un arreglo local
{
static int arreglo1[3];
cout << endl << "Valores de entrada al arreglo estático : " << endl;
for (int i = 0; i < 3 ; i++)
cout << "arreglo1 [" << i << "] = " << arreglo1[i] << "
";
cout << endl << "Valores de salida del arreglo estático : " << endl;
for (i = 0; i < 3 ; i++)
cout << "arreglo1 [" << i << "] = " << (arreglo1[i] += 5 )<< "
";
}
void automaticArrayInit (void)
automático
//
Función
que
muestra
un
arreglo
local
{
int arreglo2[3] = {1, 2, 3};
cout << endl << endl << "Valores de entrada al arreglo automático : " <<
endl;
for (int i = 0; i < 3 ; i++)
cout << "arreglo2 [" << i << "] = " << arreglo2[i] << "
";
cout << endl << "Valores de salida del arreglo automático : " << endl;
for (i = 0; i < 3 ; i++)
cout << "arreglo2 [" << i << "] = " << (arreglo2[i] += 5 )<< "
";
}
/* Programa 17.
parámetros */
Arreglos
y
#include <iostream.h>
#include <iomanip.h>
void modifyArray (int [ ], int ) ;
void modifyElement (int);
void main ( )
{
elementos
individuales
de
arreglos
como
const int arraySize = 5;
int a [arraySize] = {0, 1, 2, 3, 4};
cout << " Efecto de utilizar una llamada por referencia en un arreglo
completo : "
<< endl << "Los valores del arreglo original son : " << endl;
for (int i = 0; i < arraySize; i ++)
cout << setw(3) << a[i];
cout << endl;
modifyArray (a, arraySize);
cout << "Los valores del arreglo modificado son : " << endl;
for (i = 0; i < arraySize; i ++)
cout << setw(3) << a[i];
cout << endl << endl << endl
<< "Efecto de utilizar una llamada por valor en un elemento del
arreglo : "
<< endl << "El valor de a[3] es : " << a[3] << endl;
modifyElement( a[3] );
cout << "El valor de a[3] es : " << a[3] << endl;
}
void modifyArray (int b[ ], int sizeofArray)
{
for (int j = 0; j < sizeofArray; j++)
b[ j ] *= 2;
}
void modifyElement (int e)
{
cout << "Valor en ModifyElement es : " << (e *= 2) << endl;
}
/* Programa 18.
Inicializando arreglos multidimensionales */
#include <iostream.h>
void printArray ( int [ ][3] );
main ( )
{
int array1 [2][3] = { {1, 2, 3}, {4, 5, 6} },
array2 [2][3] = { 1, 2, 3, 4, 5 },
array3 [2][3] = { {1, 2}, {4} };
cout << " Valores en el arreglo 1 por renglón : " << endl;
printArray (array1);
cout << " Valores en el arreglo 2 por renglón : " << endl;
printArray (array2);
cout << " Valores en el arreglo 3 por renglón : " << endl;
printArray (array3);
return 0;
}
void printArray (int a[ ] [3])
{
for (int i = 0; i <= 1; i ++)
{
for (int j = 0; j <= 2; j ++)
cout << a [ i ][ j ] << '
cout << endl;
}
}
' ;
// Programa 19.
valor
Obtener el cubo de una variable utilizando llamada por
#include <iostream.h>
int cubeByValue (int);
main ( )
{
int number = 5;
cout << "El valor original de la variable es " << number << endl;
number = cubeByValue (number);
cout << "El nuevo valor es " << number << endl;
return 0;
}
int cubeByValue ( int i )
{
return n * n * n;
}
// Programa 20.
referencia
Obtiene el cubo de una variable utilizando llamada por
#include <iostream.h>
void cubeByReference (int *);
main ( )
{
int number = 5;
cout << "El valor original de la variable es " << number << endl;
cubeByReference (&number);
cout << "El nuevo valor es " << number << endl;
return 0;
}
void cubeByReference ( int *nPtr )
{
*nPtr = *nPtr * *nPtr * *nPtr;
}
// Programa 21.
Convertir letras minúsculas a mayúsculas
#include <iostream.h>
#include <ctype.h>
void convertToUppercase (char *);
void main ( )
{
char string [ ] = "caracteres y $12.4";
cout << "La cadena antes de cambiarla es : " << string << endl;
convertToUppercase ( string );
cout << "La cadena después de cambiarla es : " << string << endl;
}
void convertToUppercase ( char *sPtr)
{
while ( *sPtr != ' \0 ' )
{
*sPtr = toupper ( *sPtr );
++sPtr;
}
}
// Programa 22.
Copia una cadena
a otra
#include <iostream.h>
main( )
{
char string1[10], string2[ ] = "Hola !!";
copystr(string1,string2);
return 0;
}
void copystr(char *s1, char *s2)
{
for (; (*s1 = *s2) != '\0'; s1++, s2++);
}
// Programa 23.
Uso strncat, strcat
#include <iostream.h>
#include <string.h>
main( )
{
char s1[20] = "Happy ";
char s2[ ] = "New Year ";
char s3[40] = "";
cout << "s1 = " << s1 << endl << "s2 = " << s2 << endl;
cout << "strcat(s1, s2) = " << strcat(s1, s2) << endl;
cout << "strncat(s3, s1, 6) = " << strncat(s3, s1, 6) << endl;
cout << "strcat(s3, s1) = " << strcat(s3, s1) << endl;
return 0;
}
// Programa 24.
Uso de estructuras.
#include <iostream.h>
struct card {
char *valor;
char *palo;
};
void main( )
{
struct card a;
struct card *aPtr;
a.valor = "As";
a.palo = "Espadas";
aPtr = &a;
cout << a.valor << " de " << a.palo << endl
<< aPtr->valor << " de " << aPtr->palo << endl
<< (*aPtr).valor << " de " << (*aPtr).palo << endl;
}
// Programa 25.
Uso de Typedef, estructuras y memoria dinámica.
#include <iostream.h>
typedef struct {
int x;
int y;
} Punto;
Punto *crea_punto(int x, int y)
{
Punto *temp;
temp = new Punto;
temp->x = x;
temp->y = y;
return temp;
}
void main(void)
{
Punto *uno, *dos;
uno = crea_punto (1,2);
dos = crea_punto (5,6);
cout << "x= " << uno->x << ", y= " << uno->y << endl;
cout << "x= " << dos->x << ", y= " << dos->y << endl;
delete uno;
delete dos;
}
// Programa 26.
Creando un archivo secuencial en C
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
void main (void)
{
int account;
char name[30];
float balance;
FILE *archptr;
clrscr();
if (( archptr = fopen ("archivo.dat","w")) == NULL)
cout << "El archivo no puede abrirse ";
else
{
cout << "Dame el numero de cuenta, nombre y balance. RETURN para
terminar " << endl;
scanf(" %d %s %f ", &account, name, &balance);
while ( !feof (stdin))
{
fprintf ( archptr," %d %s %f \n",account,name,balance);
cout << " ? ";
scanf (" %d %s %f", &account, name, &balance);
}
fclose (archptr);
}
}
// Programa 27.
Leyendo e imprimiendo un archivo secuencial en C
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
void main (void)
{
int account;
char name[30];
float balance;
FILE *archptr;
clrscr();
if (( archptr = fopen ("archivo.dat", "r" )) == NULL)
cout << "El archivo no puede abrirse ";
else
{
cout << "Cuenta
Nombre
Balance" <<
endl;
fscanf ( archptr," %d %s %f ", &account, name, &balance);
while ( !feof (archptr))
{
cout << account << name << balance;
fscanf ( archptr," %d %s %f ", &account, name, &balance);
}
fclose (archptr);
}
}
// Programa 28.
Creando un archivo de acceso directo en C
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
struct clientdata {
int accNum;
char lastName[15];
char firstName[10];
float balance;
};
void main (void)
{
int i;
struct clientdata
FILE *archptr;
cliente = {0, "", "", 0.0};
clrscr();
if (( archptr = fopen ("archivo.dat","w")) == NULL)
cout << "El archivo no puede abrirse ";
else
{
for (i = 1; i <= 100; i++)
fwrite (&cliente, sizeof (struct clientdata), 1, archptr);
fclose (archptr);
}
}
//
Programa 29.
Escribiendo a un archivo de acceso directo en C
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
struct clientdata {
int accNum;
char lastName[15];
char firstName[10];
float balance;
};
void main (void)
{
struct clientdata
FILE *archptr;
cliente;
clrscr();
if (( archptr = fopen ("archivo.dat","r+")) == NULL)
cout << "El archivo no puede abrirse ";
else
{
cout << "Da el número de cuenta. (1 a 100, 0 para terminar)\n";
scanf(" %d ", &cliente.accNum);
while (cliente.accNum != 0)
{
cout << "Da apellido, nombre y balance \n ";
scanf(" %s %s %f",
&cliente.lastName,&cliente.firstName,&cliente.balanc
e);
fseek
(archptr,
(cliente.accNum
-1)
*
sizeof
(struct
clientdata),
SEEK_SET);
fwrite (&cliente, sizeof (struct clientdata), 1, archptr);
cout << "Da el número de cuenta. (1 a 100, 0 para
terminar)\n";
scanf(" %d ", &cliente.accNum);
}
}
fclose (archptr);
}
// Programa 30.
#include
#include
#include
#include
<iostream.h>
<conio.h>
<stdlib.h>
<fstream.h>
void main (void)
{
int account;
char name[10];
float balance;
clrscr();
Creando un archivo secuencial en C++
ofstream outClientFile("archivo.dat", ios::out);
if ( !outClientFile )
{
cout << "El archivo no puede abrirse ";
exit (1);
}
cout << "Dame el numero de cuenta, nombre y balance. EOF para terminar"
<< endl << "? ";
while (cin >> account >> name >> balance)
{
outClientFile << account << ' ' << name << ' ' << balance
<< endl;
cout << "? ";
}
outClientFile.close();
}
// Programa 31.
#include
#include
#include
#include
#include
Leyendo e imprimiendo un archivo secuencial en C++
<fstream.h>
<iostream.h>
<conio.h>
<iomanip.h>
<stdlib.h>
void outputLine( int acc, char *name, float bal)
{
cout << setiosflags(ios::left) << setw(10) << acc
<< setw(13) << name << setw(7) << setprecision(2)
<< setiosflags(ios::showpoint | ios::right)
<< bal << endl;
}
void main (void)
{
int account;
char name[30];
float balance;
clrscr();
ifstream inClientFile("archivo.dat", ios::in);
if ( !inClientFile ) {
cout << "Error al abrir el archivo " << endl;
exit(0);
}
cout << setiosflags(ios::left) << setw(10) << "Account"
<< setw(13) << "Name" << "Balance" << endl;
while (inClientFile >> account >> name >> balance)
outputLine(account, name, balance);
}
// Programa 32.
#include
#include
#include
#include
Creando un archivo de acceso directo en C++
<fstream.h>
<iostream.h>
<conio.h>
<stdlib.h>
struct clientdata {
int accNum;
char lastName[15];
char firstName[10];
float balance;
};
void main (void)
{
clientdata
cliente = {0, "", "", 0.0};
clrscr();
ofstream outCredit ("credito.dat", ios::out);
if ( ! outCredit ) {
cout << "Error de apertura de archivo" << endl;
exit (1);
}
for (int i = 1; i <= 100; i++)
outCredit.write ((char *)&cliente, sizeof (cliente));
}
//
Programa 33.
#include
#include
#include
#include
Escribiendo a un archivo de acceso directo en C++
<fstream.h>
<iostream.h>
<conio.h>
<stdlib.h>
struct clientdata {
int accNum;
char lastName[15];
char firstName[10];
float balance;
};
void main (void)
{
clientdata cliente;
ofstream outCredit ("credito.dat", ios::ate);
if ( ! outCredit ) {
cout << "Error de apertura de archivo " << endl;
exit (1);
}
cout << "Da el numero de cuenta (1 a 100, 0 para terminar) << endl << "?
";
cin >> cliente.accNum;
while (cliente.accNum > 0 && cliente.accNum <= 100)
{
cout << "Dame el apellido, el nombre y el balance " << endl << "?
";
cin >> cliente.lastName >> cliente.firstName >> cliente.balance;
outCredit.seekp ((cliente.accNum - 1) * sizeof(cliente));
outCredit.write ((char *)&cliente, sizeof (cliente));
cout << "Da el numero de cuenta (1 a 100, 0 para terminar) <<
endl << "? ";
cin >> cliente.accNum;
}
}
//
Programa 34.
#include
#include
#include
#include
#include
Leyendo
un archivo de acceso directo en C++
<fstream.h>
<iostream.h>
<conio.h>
<iomanip.h>
<stdlib.h>
struct clientData
{
int account;
char lastName[15];
char firstName[10];
float balance;
};
void outputLine(clientData c)
{
cout << setiosflags(ios::left) << setw(6) << c.account
<< setw(16) << c.lastName << setw(11) << c.firstName
<< setw(10) << setprecision(2)
<< setiosflags(ios::showpoint | ios::right)
<< c.balance << endl;
}
void main (void) {
clientData cliente;
clrscr();
ifstream inClientFile("archivo.dat", ios::in);
if ( !inClientFile ) {
cout << "Error al abrir el archivo " << endl;
exit(1);
}
cout << setiosflags(ios::left) << setw(6) << "Acct"
<< setw(16) << "Last Name" << setw(11)
<< "First Name" << setiosflags(ios::right)
<< setw(10) << "Balance" << endl;
inClientFile.read ((char *) &cliente, sizeof(clientData));
while ( !inClientFile.eof ( ) )
{
if (cliente.account != 0)
outputLine (cliente);
inClientFile.read ((char *) &cliente, sizeof(clientData));
}
}