Pascal/Turbo Pascal - QUIERO SABER COMO CREAR ARCHIVO!!!!!

   
Vista:
Imágen de perfil de ESTEBAN VICENTE

QUIERO SABER COMO CREAR ARCHIVO!!!!!

Publicado por ESTEBAN VICENTE tcmartinezesteban@gmail.com (1 intervención) el 10/04/2014 15:07:59
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
program listado_articulos;
uses crt;
type
articulos=record
 
codigo:longint;
precio:Real;
 
end;
 
var
opcion:char;
 
archivo: file of articulos;
miarchivo:articulos;
acc:boolean;
 
 
procedure cargar (var miarchivo:articulos);
begin
reset(archivo);
write('ingrese el codigo ');read(miarchivo.codigo);
write('ingrese el precio ');read(miarchivo.precio);
close(archivo);
end;
 
 
{MENU}
function menu : char;
var
opcion:char;
begin
	write('CARGAR ARTICULO (1) ');
	writeln;
	write('SALIR (S) ');
	writeln;
	write('ELIJA UNA OPCION ');read(opcion);
	menu:=opcion;
end;
 
 
 
begin
{NO se como crear el archivo , para guardar los articulos dentro}{****
* ******************************************************************}
 
	acc:=false;
	while acc=false do
	begin
	opcion:=menu();
	if opcion='1'
		then
			cargar(miarchivo)
	else
		if (opcion='s') or (opcion='S')
			then
				Acc:=true;
				Writeln('Adios');
 
	end;
end.

LO QUE NO ES COMO CREAR EL ARCHIVO, DONDE VOY A GUARDAR LA INFORMACION DE LOS ARTICULOS. GRACIAS POR SU AYUDA
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

QUIERO SABER COMO CREAR ARCHIVO!!!!!

Publicado por Diego (98 intervenciones) el 10/04/2014 16:44:27
Estoy con algo de prisa, pero me pareció a simple vista que no utiliz´s correctamente las operaciones sobre archivos.
Te doy una descripción que tome de esta pagina: http://moisesrbb.tripod.com/unidad8p.html

Archivos de acceso secuencial

Los archivos de acceso secuencial son llamados también archivos de texto, están formados por cadenas de caracteres separadas unas de otras por los códigos retorno de carro/avance de línea, que corresponden a los caracteres 13/10 del código ASCII. El final del archivo se indica mediante el caracter ASCII 26, que también se expresa como ^Z o EOF.

Es posible visualizar estos archivos con la orden TYPE del sistema operativo DOS y se pueden editar con cualquier editor de textos.

Este tipo de archivos solo permiten operaciones de lectura y escritura secuenciales, la unica forma de modificarlos es agregando líneas al final del archivo.

Los pasos para leer o escribir en un archivo de este tipo son:

Declarar una variable de tipo texto y asociarla al nombre de un archivo. A esto también se le llama declarar el archivo.
Abrir el archivo ya sea para lectura o escritura.
Leer o escribir datos en el archivo.
Cerrar el archivo

Declaración de un archivo

Para declarar un archivo primero se declara una variable tipo text de la siguiente forma:
VAR
VarArchivo : Text;

Una vez declarada la variable se asigna al nombre de algun archivo:

ASSIGN (VarArchivo, NombreArchivo); Donde NombreArchivo es una cadena de caracteres que contiene el nombre del archivo, la unidad de disco donde se encuentra y el directorio. Por ejemplo:

ASSIGN (VarArchivo, 'C:\DOS\PRUEBA.TXT');
Abrir archivos

Exsiten tres formas de abrir un archivo:
Rewrite Reset Append
Escribir datos en un archivo

Para escribir datos a un archivo se utilizan las instrucciones Write y WriteLn, como si se quisiera escribir a la pantalla, con la diferencia de que se especificará la variable de archivo ya declarada. Ejemplo:

WriteLn(VarArchivo, 'Prueba de archivos'); Esta sentencia grabaría el texto 'Prueba de archivos' en el archivo asignado a VarArchivo.
Leer datos de un archivo

Para leer los datos de un archivo de acceso secuencial se utilizan las instrucciones Read y ReadLn.

La instrucción Read lee uno o varios datos del archivo abierto y deja el puntero en el mismo renglón en el cual leyó los datos, en cambio ReadLn lee los datos y mueve el puntero al siguiente renglón.
Fin del archivo

Normalmente los archivos de este tipo se leen renglón por renglón hasta llegar al final del mismo. Cuando se conoce de antemano el tamaño del archivo es posible utilizar un ciclo FOR, pero es más seguro utilizar la función EOF la cual es verdadera despues de que el programa lee la última linea de un archivo de acceso secuencial.

La sintaxis de la función EOF es:

EOF (VaribleArchivo);

Es común realizar la verificación de la función con un ciclo WHILE como en el ejemplo siguiente:
WHILE NOT EOF(Archivo) DO
BEGIN
ReadLn(Archivo, Datos);
WriteLn(Datos);
END;
Cerrar archivos

Para asegurar que toda la información se grabe en el disco correctamente es necesario cerrar el archivo antes de que se termine la ejecución del programa, de lo contrario se corre el riego de que la última información que se haya accesado no se grabe en su totalidad.

La instrucción para cerrar un archivo es Close, y su sintaxis es:

Close (VaribleArchivo);
Función Eoln

La función Eoln sirve para verificar si el puntero ha llegado al final de la linea. Regresa el valor verdadero si se encuentra al final. Comunmente se utiliza en las lecturas caracter por caracter.
Agregar datos a un archivo de texto

Para añadir datos a un archivo de texto son necesarios los siguientes pasos:

Asignar un archivo a una variable con Assign
Agregar los datos con el procedimiento Append
Escribir los datos
Cerrar el archivo

A continuación se ilustra un ejemplo de un programa que agrega una linea a un archivo de texto:
PROGRAM Archivo;
VAR
Texto : TEXT;

BEGIN
Assign (Texto, 'PRUEBA.DAT');
Append(Texto);
WriteLn(Texto, 'Agregando una linea al archivo PRUEBA.DAT');
Close (Texto)
END.
Archivos de acceso directo

Un archivo de acceso directo esta formado por un conjunto de partes individuales que pertenecen al mismo tipo de datos. Cada uno de los componentes del archivo es llamado registro.

Cada uno de los componentes de este tipo de archivos es accesible directamente.

Los archivos de acceso directo son también llamados archivos con tipos o tipeados.
Estructura del archivo

A diferencia de los archivos secuenciales, los archivos tipeados no estan compuestos de lineas de caracteres, sino que se acomodan en registros con estructuras fijas. La longitud de los registros esta determinada por la cantidad de bytes que se necesitan para almacenar el tipo de datos que contendrá el registro.

Por ejemplo, si se van a almacenar números enteros en un archivo, cada registro servirá para un número específico y ocupará 2 bytes, el siguiente registro utilizará los dos bytes siguientes del archivo y así sucesivamente hasta completar la cantidad de datos que se vayan a almacenar.

Este tipo de archivos no pueden ser visualizados con la instrucción type del sistema operativo debido al formato utilizado para guardarlos.
Declaración de un archivo

Para declarar un archivo de acceso directo se realiza con las palabras reservadas FILE OF, su sintaxis es la siguiente:

VariableArchivo : FILE OF TipoElementos;

Esta declaración se realiza en la sección correspondiente a la declaración de las variables. Ejemplo:
PROGRAM Archivo_Tipeado;
VAR
Archivo : FILE OF Integer;
BEGIN
END.

Normalmente no se desea crear archivos que puedan almacenar un solo tipo de datos ya que se requeririan varios archivos, por ejemplo para alguna base de datos: uno para los nombres, otro para apellidos, otro para la edad, etc. Para evitar este inconveniente es posible usar registros del tipo RECORD, que permiten grabar en un solo registro un grupo de datos que pueden ser de diferentes tipos, uno de tipo INTEGER, uno de tipo STRING, etc.

Los registros del tipo record deben ser declarados antes de las variables en una sección llamada TYPE con el siguiente formato:

TYPE

Nombre_Reg = RECORD

Campo_del_registro_1 : Tipo;
Campo_del_registro_2 : Tipo;
...
Campo_del_registro_n : Tipo;
END;

Donde Nombre_Reg es el nombre del registro que se utilizará, Campo_del_Registro_x son las variables que estarán contenidas en el registro y Tipo es el tipo de cada una de las variables del registro.

La sección TYPE se escribe antes de la declaración de las variables.

Como ejemplo, si se quiere crear un archivo el que se guarden el nombre, domicilio, edad y estado civil de un grupo de personas el primer paso a realizar es crear un registro que contenga todos estos campos:

TYPE

Datos = RECORD

Nombre : String[40];
Domicilio : String[60];
Edad : Integer;
EdoCivil : String[10];
END;

El siguiente paso es declarar un archivo del tipo Datos así como una variable del mismo tipo de los que se utilizarán en el archivo:

VAR

Archivo : FILE OF Datos;
Persona : Datos;

Asignación de un archivo

Aún cuando se tenga declarado el archivo no es posible grabar nada en él si no se le asigna un nombre real para guardarlo en el disco. El proceso de dicha asignación es el mismo que para los archivos de texto:

Assign (Archivo, 'Nombre.ext');

Nombre.txt puede ser una constante, una variable o estar escrita directamente en el programa. Naturalmente debe cumplir con todas las reglas para nombrar un archivo.
Abrir archivos

Una vez declarado un archivo ya es posible abrirlo. En caso de querer abrir un archivo nuevo se utiliza la instrucción Rewrite, o si el archivo ya existe en el disco se abre con el procedimiento Reset.

No existe ninguna diferencia entre la apertura de un archivo de acceso directo para su lectura o para su escritura.

Si al utilizar el procedimiento Rewrite el archivo asignado ya existía se eliminará del disco y se creará uno nuevo, por lo mismo se debe tener ciudado al momento de abrir estos archivos.
Registro actual y tamaño de un archivo

La función FileSize regresa el tamaño de un archivo, o mejor dicho devuelve el número de registros contenidos en éste.

Al momento de abrir un archivo nuevo la función FileSize regresa el valor de 0, lo que significa que el archivo no tiene datos guardados en él.
Posicionamiento en el interior de un archivo

Cada uno de los registros de un archivo esta referenciado por un número específico comenzando desde el registro 0 y aumentando de 1 en 1.

La función FilePos devuelve el número de registro actual, su sintaxis es:

FilePos (VariableArchivo)

VariableArchivo es la variable a la cual se asignó un nombre de archivo en el disco.

Para moverse a un registro determinado se utiliza la función Seek, con la siguiente sintaxis:

Seek (VariableArchivo, NumRegistro);

Para moverse al final del archivo para agregar un nuevo registro se utiliza este mismo comando con el parametro NumRegistro como sigue:

Seek (VariableArchivo, FileSize(VariableArchivo));

Cuando se avanza en un archivo registro por registro se utiliza la función EOF para determinar si ya se llegó al final del archivo.
Lectura y escritura de archivos

Para la lectura y escritura en un archivo de acceso directo unicamente se utilizan los procedimientos Read y Write. Despues de cada operacion de lectura o escritura el puntero se posiciona en el siguiente registro.

Para estar seguros de que se leera el registro que se desea se debe emplear el procedimiento seek antes de cualquier procedimiento de lectura o escritura.
Cerrar un archivo

Para cerrar los archivos abiertos se procede igual que en uno de acceso secuencial, utilizando el procedimiento close:

Close (VariableArchivo);
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar

QUIERO SABER COMO CREAR ARCHIVO!!!!!

Publicado por ramon (2072 intervenciones) el 11/04/2014 00:40:25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
{Mira esto te ayudara}
 
type
articulos=record
 
codigo:longint;
precio:Real;
 
end;
 
var
opcion:char;
 
archivo: file of articulos;
miarchivo:articulos;
acc:boolean;
 
 
procedure guardaregistros(reg : articulos);
begin
     assign(archivo,'datos.dat');
  {$I-} reset(archivo); {$I+}
  if ioresult <> 0 then
  begin
       rewrite(archivo);
       seek(archivo,0);
        write(archivo,reg);
        close(archivo);
   end
 else
      begin
          seek(archivo,filesize(archivo));
          write(archivo,reg);
        close(archivo);
      end;
end;
 
 
  {Con esto guardas el archivo un registro como ves para mas de veras llamar a la procedimiento cada vez que lo rellenes nuevo}
 
  para cargar in registro o todos sera
 
  procedure cargaregistros;
   begin
        assign(archivo,'datos.dat');
  {$I-} reset(archivo); {$I+}
  if ioresult <> 0 then
  begin
       writeln('Error de Archivo No Encontrado');
        readkey;
  end
else
   begin
        seek(archivo,0); {tomamos el archivo numero 0 si quieres otro aumenta este numero asta final de archivo}
         read(archivo,miarchivo);   {para localizar el untimo este sera filesize(archivo) - 1}
          writeln(miarchivo.codigo);
           writeln(miarchivo.precio:0:2);
           readkey;
         close(archivo);
   end;
   end;
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar