programación ii . examen junio 2006-2007

PROGRAMACIÓN II . EXAMEN JUNIO 2006-2007
Teórico prácticas.
1.
void sorpresa1 (Tpersona *p)
{
if(p!=0)
{
printf("nombre: %s",p->nombre);
printf("ape: %s\n",p->ape);
sorpresa1(p->sig);
free (p);
}
}
No falla, escribe los datos de la lista desde el primer nodo hasta el último y a la vuelta de la recursividad
borra los nodos. El problema es que al salir de la recursividad “p” no está apuntando a NULL, borrar
hemos borrado, pero hemos dejado a “p” apuntando a una dirección de memoria en vez de a NULL:
void sorpresa2 (Tpersona *p)
{
if(p!=0)
{
printf("nombre: %s",p->nombre);
printf("ape: %s\n",p->ape);
free (p);
sorpresa2(p->sig);
}
}
Este si falla, da error, ya que antes de hacer la llamada recursiva hemos borrado el nodo por lo cual, al
intentar hacer la llamada recursiva no tenemos ningún campo siguiente.
void sorpresa3 (Tpersona *p)
{
if(p!=0)
{
sorpresa3(p->sig);
printf("nombre: %s",p->nombre);
printf("ape: %s\n",p->ape);
free (p);
}
}
A este le pasa lo mismo que a sorpresa1, solo que en vez de escribir los nodos desde el primero hasta el
último los escribe desde el último al primero, pero deja “p” sin apuntar a NULL.
2.
a.)
Hay dos tipos de fichero, binarios y de texto; dentro de los de texto están los de texto con formato y sin
formato.
- Ficheros de texto sin formato
Como hemos dicho antes los ficheros de texto son aquellos que almacenan caracteres, es decir signos del
alfabeto, signos de números, signos de puntuación y signos especiales como retorno de carro y salto de
línea o los signos más allá .del código 128, donde comienzan los juegos de caracteres especiales.
- Ficheros de texto con formato
Este tipo de ficheros de texto es el mismo que el de ficheros de texto sin formato, lo único que los
diferencia es que los datos leídos del fichero y transformados en otro tipo de datos. Los datos
almacenados en estos ficheros estarán colocados con un formato específico, es decir, los datos se colocan
con un convenio especial que nosotros habremos determinado, por ejemplo, cada dato aparecerá separado
por un espacio en blanco o por un salto de línea, etc... a esto se le denomina formato
- Ficheros de texto con formato
Este tipo de ficheros almacenan cualquier tipo de datos, simples (caracteres, números enteros, etc.) o
compuestos (registros). Si los abrimos con un editor de texto, no seremos capaces de comprender el
contenido que se nos muestra.
Una diferencia importante entre los dos tipos de ficheros es que la longitud de registro en los binarios es
siempre la misma, mientras que en los de texto no, con lo cual podremos tener un acceso aleatorio en los
binarios mientras que en los de texto no.
b)
- Texto sin formato
Lectura
char * fgets (char * s, int n, FILE * pfr);
Escritura
int fputs (char * s, FILE * pfw);
- Texto con formato
Lectura
int fprintf (FILE * pfw, formato,variables);
Escritura
int fscanf (FILe * pfw, formato , variables);
- Bianrios
Lectura
fread (&registro,sizeof(registro),1,pf);
Escritura
fwrite(&registro,sizeof(registro),1,pf);
c)
Supongamos la definición de Tpersona del ejercicio 1.
struct Registro
{
char nombre[20], ape[30] ;
};
void Rellenarfichero (char *nombre, Tpersona *l)
{
FILE *f;
Registro R ;
f= fopen(nombre, “wb+”);
if(f == NULL)
printf ("error al abrir el fichero ");
else
{
while(l)
{
strcpy(R.nombre, l->nombre);
strcpy(R.ape, l->ape);
fwrite(&R,sizeof( R), 1, f) ;
l=l->sig;
}
}
printf ("Lista volcada a fichero");
}
3.
void main()
{
int x=12;
incrementa(&x);
decrementa(x);
printf("%d",x);
}
void incrementa (int *x)
{
(*x)++;
}
void decrementa (int x)
{
--x;
}
El resultado es 13, x se incrementa en uno pero no se llega a decrementar, ya que a la función
decrementar le pasamos x por valor y no por referencia.
Parte Práctica
Ejercicio 1.
a)
typedef struct
{
char titulo[N], autores[N];
unsigned long isbn;
int num, ndisp;
} LIBRO;
typedef struct
{
char titulo[N], autores[N];
unsigned long isbn;
int num, ndisp;
unsigned int editado;
} LIBRO2;
int Conversión (char *bd_vieja, char *bd_nueva);
{
FILE *vieja, *nueva;
LIBRO rviejo;
LIBRO2 rnuevo;
vieja= fopen(bd_vieja, “rb+”);
nueva= fopen(bd_vieja, “wb+”);
if(vieja = = NULL)
{
printf ("error al abrir la b.d. vieja ");
return –1;
}
if(nueva = = NULL)
{
printf ("error al abrir la b.d. nueva ");
return –1;
}
while(!feof(vieja))
{
if ( fread(&rviejo,sizeof(rviejo),1,vieja) )
{
strcpy(rnuevo.titulo, rviejo.titulo);
strcpy(rnuevo.autores, rviejo.autores);
rnuevo.isbn = rviejo.isbn;
rnuevo.num = rviejo.num;
rnuevo.ndisp = rviejo.ndisp;
rnuevo.isbn = rviejo.isbn;
printf (“titulo: %s, autor: %s, isbn: %d\n”,rnuevo.titulo, rnuevo.autor,
rnuevo.isbn);
printf(“dime el año de edicion:\n”);
scanf(“%d”,&(r.editado)) ;
fread(&rnuevo,sizeof(rnuevo),1,nuevo);
}
}
fclose(vieja);
fclose(nueva);
return 0;
}
b)
Fichero indexado.
El índice guardará dos datos, por un lado el ISBN y la posición en bytes de cada registro dentro del
fichero binario. Suponemos que el índice guardará N elementos, por ejemplo 100.
struct Indice
{
unsigned long isbn;
unsigned int posicion;
};
Tendremos una variable a nivel global que n os indicará cuantos elementos hay en el índice.
void Añadir ( FILE * p, Indice *indice_bd_nueva, int *cuantos)
{
char seguir;
Indice alta;
LIBRO2 nuevo;
int i,j;
fseek(p,0,SEEK_END);
do
{
if(*cuantos>=N)
{
printf(“no hay sitio en el índice para más altas\n”);
getchar();
return;
}
alta.posición=ftell(p);
DatosDelNueboLibro(nuevo);
fwrite(&nuevo,sizeof(nuevo),1,p);
alta.isbn=nuevo.isbn;
i=0;
while ((i<*cuantos) && (indice_bd_nueva[i].isbn<nuevo.isbn))
i++;
if(i= =*cuantos)
indice_bd_nueva[*cuantos]=alta;
else
{
for(j=*cuantos; j>i; j--)
indice_bd_nueva [j] =
indice_bd_nueva [j-1];
indice_bd_nueva[i]=alta;
}
(*cuantos)++;
printf(“quieres dar otro alta?:”);
scanf(“%c”,letra);
fflush(stdin);
}
while (toupper(seguir)!= ‘N’);
}
Ejercicio 2.
typedef struct seleccion
{
char pais[20], grupo, seleccionador[30];
struct selección *sig;
} T_SECLECCION;
T_SELECCION * ordenar (T_SELECCIÓN *L)
{
T_SELECCIÓN *primero, *aux, *cambiar;
if (L!=NULL)
{
primero = L;
while (primero->sig != 0)
{
cambiar = primero;
aux=primero->sig;
while(aux)
{
if(strcmp(primero->pais, aux->pais) > 0)
cambiar = aux ;
aux=aux->sig ;
}
if (cambiar != primero
Intercambiar(primero,cambiar);
primero=primero->sig;
}
}
return L;
}