PDF de programación - Apunte de VC++ 6 - Capítulo XII

Apunte de Visual C++

 

Por: Demian Panello        [email protected]      
Capítulo XII
Indice rápido del capítulo 12:

Tipos de archivos.
La clase CFile.
Proyecto que lee y escribe un archivo de texto.
Abrir un archivo, (función Open()).
Escribir en un archivo, (función Write()).
Modos de apertura de un archivo.
Leer de un archivo, (función Read()).
Archivos de estructuras.
Evitar que al pulsar ESC se cierre un diálogo.
Grabar estructura en un archivo.
Mover el puntero del archivo al final del mismo.
Asignarle el foco a un control determinado.
Averiguar la cantidad de registro que contiene un archivo de estructuras.
Leer un registro de un archivo de estructuras.
Mover el puntero del archivo.

 

TIPOS DE ARCHIVOS:

En este capítulo veremos los conceptos básicos de la manipulación de archivos en VC++.
Existen 2 importantes grupos de archivos:
­ Archivos de texto.
­ Archivos binarios.
 
Un archivo de texto es aquel cuyo contenido son caracteres, (de la tabla ASCII), que además representan por si solos
información. Por ejemplo, archivos de texto son los archivos .cpp que uno crea cuando programa en C++, también son de
texto los archivos .txt y en general cualquier archivo, (no importa la extensión), cuyo contenido sean caracteres.
Los archivos binarios son bien diferentes a los de texto y la diferencia radica en el formato. El contenido de un archivo
binario es absurdo y carece de sentido si lo editamos con algún editor de texto, (ejemplo Notepad o el EDIT del DOS), y
esto es así en principio por dos cosas: por un lado, el conjunto de caracteres que están en el archivo no representan alguna
información lógica al momento de visualizarlos como simples caracteres y fundamentalmente porque la creación del archivo
no sigue la pauta de la de un simple texto, esto es, se creó el archivo para que guarde información con un formato
determinado.
Por ejemplo guardar en un archivo el contenido de una estructura o de un arreglo de estructuras no sigue la regla simple de
los archivos de texto de un caracter detrás del otro, saltos de línea, etc; y si bien la estructura almacena caracteres estos ya
están subordinados a campos lo que cambia el formato del manejo de los datos. Ya no es simplemente texto, sino,
información de bytes, (seguramente muchos de esos bytes son los caracteres almacenados en el campo APELLIDO de la
estructura pero muchos otros no).

La MFC ofrece una clase que sirve como "envoltorio" de las funciones para manipular archivos del SDK de Windows. Esta
clase se llama CFile.

Vamos a hacer una aplicación que nos permitirá crear y editar un archivo de texto; siempre leerá y escribirá el mismo
archivo, "pp.txt", en el directorio actual.

Cree un proyecto MFC llamado "Archivos1", basado en diálogos y acepte todas las opciones por defecto, (si quiere puede
quitar la creación del diálogo Acerca de).

Diseñe el diálogo como muestra la figura:

Especifique las siguientes propiedades de los controles:

Control de edición:

­ ID: IDC_EDIT1

­ Tildar los estilos: Multiline, Horizontal Scroll, Auto HScroll, Vertical Scroll, Want Return y Border.

Botones: IDC_GUARDA, (Guardar "pp.txt") e IDC_ABRIR, (Cargar "pp.txt").

Con el Class Wizard cree una variable de tipo CString llamada m_strTexto para el control de edición, (recuerde Class
Wizard ­> Member Variables ­> Seleccione IDC_EDIT1 y pulse Add Variable).

Ahora hay que escribir en el mensaje WM_LBUTTONDOWN del botón IDC_GUARDA el código que crea el archivo
"pp.txt" y guarda en él el contenido del cuadro de edición.

 void CArchivos1Dlg::OnGuarda() 
{
    
    CFile Archi; (1)
    
    Archi.Open ("pp.txt", CFile::modeCreate | CFile::modeWrite); (2)     //Abro el archivo

    UpdateData(TRUE);  (3)
    
    Archi.Write ( m_strTexto, m_strTexto.GetLength ());  (4)
    Archi.Close ();  (5)
    m_strTexto="";  (6)
    UpdateData(FALSE); (7)
    AfxMessageBox("Archivo guardado con éxito");  (8)

}

En la línea (1) se crea un objeto CFile llamado Archi y con él en la línea (2) abrimos el archivo por medio de la función
miembro Open(). Esta función recibe 2 parámetros, el primero es una cadena que indica el archivo que se va abrir,
(obviamente se puede incluir el path) y el segundo parámetro especifica el modo de apertura que se pueden combinar con las
siguientes constantes:

 

CFile::modeCreate   Para crear un nuevo archivo. Si ya existe borra el contenido.
CFile::modeNoTruncate   Se combina con modeCreate. Si el archivo ya existe lo abre sin borrar el contenido sino
lo crea.
CFile::modeRead   Abre como sólo lectura.
CFile::modeReadWrite   Abre para lectura y escritura.
CFile::modeWrite   Abre para escribir.
CFile::modeNoInherit   No permite que el archivo sea heredado por un proceso descendiente.

CFile::shareDenyNone   Permite que otro proceso lea y/o escriba en el archivo.
CFile::shareDenyRead   No permite que otro proceso lea el archivo.
CFile::shareDenyWrite   No permite que otro proceso escriba en el archivo.
CFile::shareExclusive   No permite que otro procesa pueda escribir y leer en el archivo.
CFile::typeText   Especifica que el archivo se abre en modo texto con retorno de carro y salto de línea, (sólo se usa en
clases derivadas).
CFile::typeBinary   Especifica que el archivo se abre en modo binario, (sólo se usa en clases derivadas).

En nuestro caso abrimos el archivo para crearlo y escribir.

Open() retorna distinto de 0 en caso que la apertura tenga éxito y 0 en caso que falle por algún motivo, (por ejemplo el disco
esta protegido contra escritura). Deberíamos colocar esta sentencia evaluada en un IF para que sea más prolijo el código,
pero bueno, por ahora confiemos que se podrá abrir sin problemas.

Una vez abierto el archivo transfiero el contenido del cuadro de edición a la variable miembro m_strTexto con la conocida
función UpdateData(TRUE). Y en (4) escribimos en el archivo el contenido de m_strTexto con la función Write. Dos
parámetros necesita: la variable de tipo CString a escribir y la longitud de la misma.

Luego se cierra el archivo con Close(), se "limpia" la variable m_strTexto y se vuelve a llamar a UpdateData() esta vez con
el parámetro FALSE para que pase el contenido de la variable al cuadro de edición, lo que da a lugar que el cuadro de
edición quede vacío.

Puede probar la aplicación. Escriba algo en el cuadro de edición y luego pulse el botón "Guardar pp.txt". Para verificar si
realmente escribió en el archivo vaya a la carpeta donde se encuentre el proyecto y edite "pp.txt".

Escribamos ahora el código que me permite editar el archivo en el cuadro de edición. Para esto agregue el mensaje
OnAbrir() para el botón IDC_ABRIR.

Para este caso hay que tener en cuenta que quizás el archivo a editar sea muy grande como para intentar leerlo de una vez,
por eso vamos a leer, (mientras haya texto que leer), de a pedazos de 512 bytes, (o caracteres, es un estándar este número en
lo que respecta a lectura en bloques). El procedimiento sería:

­ Abrir el archivo para sólo lectura.

­ Si se pudo abrir, entonces, leer 512 bytes.

­ Mientras la cantidad de bytes leídos es mayor a 0, se "acumula" lo leído en la variable miembro m_strTexto y se vuelve a
leer 512 bytes.

­ Cuando no haya nada que leer se actualiza el cuadro de edición con el contenido de m_strTexto y se cierra el archivo.

Más o menos debería se así, veamos entonces lo que hay que escribir en OnAbrir().

void CArchivos1Dlg::OnAbrir() 
{
    CFile Archi;
    char strLeo[512]; (1)
    UINT bLeidos;       (2)
    
    
    Archi.Open ("pp.txt", CFile::modeRead);    //Abro el archivo
    
    if (Archi)   (3) //si retorna distinto de NULL es porque se pudo abrir
    {
        m_strTexto="";
        bLeidos=Archi.Read (strLeo,sizeof(strLeo)­1); (4)  //leo 511 bytes
        while (bLeidos)    (5)
        {

            strLeo[bLeidos]=NULL; (6)                //Agrego terminación nula al final
            m_strTexto += CString(strLeo); (7)       //lo acumulo en la variable

            bLeidos=Archi.Read (strLeo,sizeof(strLeo)­1);  (8)  //leo otra vez
        }
        Archi.Close ();   //cierro el archivo
    }

    UpdateData(FALSE);  (9)
    
}

En (1) se declara una cadena de 512 caracteres, en realidad 511 ya que el último caracter de una cadena en C es '\0', el
caracter nulo, (NULL), que indica donde termina la cadena, (en muy importante tener presente ésto). En (2) se declara un
entero largo, (UINT), donde se almacenará la cantidad de bytes leído en cada intento.

Se intenta abrir el archivo para sólo lectura y en (3) se verifica que Archi no sea NULL porque sino implicaría que no se
pudo abrir el archivo. En caso de no haber problemas, en (4) se hace una lectura del archivo con la función Read().

Dos parámetros son necesarios para una simple lectura, primero la variable de tipo cadena, (puede ser CString o como en
nuestro caso un arreglo de char) y luego el tamaño de la misma que en caso de usar una variable char se obtiene con el
operador sizeof(), si fuera CString se utilizaría GetLength() como cuando escribimos en el archivo. Se preguntará por qué se
hace sizeof(strLeo)­1 y no simplemente sizeof(strLeo); bien, el tema es que como usamos una cadena de tipo char
tendremos que "poner a mano" nosotros el caracter nulo en la última posición de la cadena, entonces en vez de leer 512
bytes leemos 511 y nos sobra una posición para poder colocar el caracter de fin de cadena.

Read() retorna la cantidad bytes leidos, entonces en (5) se verifica si algo se leyó, o sea si bLeidos es distinto de 0 porque de
mientras sea así se continuará leyendo, (es una forma de detectar el fin de archivo).

Dentro del mientras, en (6) se le coloca a la cedena la terminación nula, NULL, y se acumula su contenido en la variable
miembro m_strTexto, línea (7). En (8) se vuelve a leer.

Cuando no haya más bytes que leer el flujo sale del ciclo mientras, se cierra el archivo con Close() y se transfiere todo el
contenido de m_strTexto, (que es justamente el contenido del archivo), a el cuadro de edición por m