Operaciones de lectura y escritura de archivos txt en vc

Las operaciones son muy comunes en programación. Si puedes conocer bien todas las operaciones, puedes encontrar la mejor solución según la situación real y escribir código eficiente en poco tiempo, por lo que es muy importante. dominar hábilmente las operaciones con archivos. Este artículo brindará una introducción completa a las operaciones de archivos en Visual C++ y realizará un análisis detallado de algunos problemas difíciles que a menudo se encuentran en las operaciones de archivos.

1. Búsqueda de archivos

Al operar en un archivo, si no sabe si el archivo existe, primero debe buscar. Hay una clase CFileFind en MFC que se utiliza especialmente para la búsqueda de archivos. Puede utilizarla para buscar archivos de forma rápida y sencilla. El siguiente código demuestra el uso más básico de esta clase.

CString strFileTitle;

Buscador CFileFind;

BOOL bWorking = finder.FindFile( "C:\\windows\\sysbkup\\*.cab ")

while(bWorking)

{

bWorking=finder.FindNextFile()

strFileTitle=finder.GetFileTitle();

}

2. Cuadro de diálogo abrir/guardar archivo

Cuando se permite a los usuarios seleccionar archivos para operaciones de apertura y guardado, se utiliza el cuadro de diálogo abrir/guardar archivo. La clase CFileDialog de MFC se utiliza para implementar esta función. Al declarar un objeto usando CFileDialog, el primer parámetro BOOL se usa para especificar la apertura o el guardado del archivo. Cuando es VERDADERO, se construirá un cuadro de diálogo para abrir el archivo y, cuando es FALSO, se creará un cuadro de diálogo para guardar el archivo. construido.

Al construir un objeto CFileDialog, si se especifica el estilo OFN_ALLOWMULTISELECT en el parámetro, se pueden realizar múltiples operaciones de selección en este cuadro de diálogo. En este momento, es importante prestar atención a la asignación de memoria para m_ofn.lpstrFile de este objeto CFileDialog para almacenar todos los nombres de ruta de archivo devueltos por la operación de selección múltiple. Si no se realiza ninguna asignación o la memoria asignada es demasiado pequeña, la memoria asignada es demasiado pequeña. la operación fallará. El siguiente programa demuestra el uso del cuadro de diálogo para abrir archivos.

CFileDialog mFileDlg(TRUE,NULL,NULL,

OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_ALLOWMULTISELECT,

"Todos los archivos (*.*)|*.*|| ",AfxGetMainWnd());

CString str( " ",10000);

mFileDlg.m_ofn.lpstrFile=str.GetBuffer(10000);

str.ReleaseBuffer();

POSICIÓN mPos=mFileDlg.GetStartPosition();

CString pathName( " ", 128);

Estado de CFile; p>

p>

while(mPos!=NULL)

{

pathName=mFileDlg.GetNextPathName(mPos);

CFile: :GetStatus(nombreruta, estado );

}

3. Leer y escribir archivos

Leer y escribir archivos es muy importante y se describirá en detalle a continuación. La forma más común de leer y escribir archivos es usar CFile directamente. Por ejemplo, se pueden usar los siguientes métodos para leer y escribir archivos:

//Leer el archivo

char. sRead[2 ];

CFile mFile(_T( "user.txt "),CFile::modeRead

if(mFile.GetLength() <2)

return;

mFile.Read(sRead,2);

mFile.Close()

//Escribe el archivo

CFile mFile(_T( "user.txt "), CFile::modeWrite|CFile::modeCreate

mFile.Write(sRead,2

); mFile .Flush();

mFile.Close();

Aunque este método es el más básico, su uso es engorroso y su función es muy sencilla. Lo que te recomiendo es usar CArchive, que es sencillo de usar y muy potente. Primero, use CFile para declarar un objeto y luego use el puntero de este objeto como parámetro para declarar un objeto CArchive. Puede almacenar varios tipos de datos complejos de manera muy conveniente. Vea el ejemplo a continuación para saber cómo usarlo.

//Escribe el archivo

CString strTemp;

CFile mFile

mFile.Open( "d:\\ dd\; \try.TRY ",CFile::modeCreate|CFile::modeNoTruncate|CFile::modeWrite);

CArchive ar(&mFile,CArchive::store);

ar < < ar.Close();

mFile.Close();

//Leer el archivo

CFile mFile

if( mFile.Open( "d:\\dd\\try.TRY ",CFile::modeRead)==0)

return

CArchive ar(&mFile ,CArchive:: cargar);

ar> > strTemp

ar.Close();

mFile.Close()

CArchive Los operadores < y >> se utilizan para leer y escribir tipos de datos simples. Para acceder a objetos de clases derivadas de CObject, utilice ReadObject() y WriteObject(). También puede utilizar ReadClass() y WriteClass() de CArchive para leer y escribir clases, como:

//Storage CAboutDlg class

ar.WriteClass(RUNTIME_CLASS(CAboutDlg));

//Leer la clase CAboutDlg

CRuntimeClass* mRunClass=ar.ReadClass()

//Usar la clase CAboutDlg

CObject* pObject=mRunClass-> CreateObject();

((CDialog* )pObject)-> DoModal()

Aunque la estructura de documento/vista proporcionada por VC también puede ser utilizado Estas operaciones no son fáciles de entender, usar y administrar. Por lo tanto, aunque muchos libros de introducción a VC dedican mucho tiempo a describir la estructura del documento/vista, le sugiero que no utilice su documentación. Hay muchos libros sobre cómo separar documentos/vistas, incluido el muy famoso "Visual C++ Technical Insider".

Si la operación de archivo que desea realizar es simplemente leer y escribir una línea completa de cadenas, le sugiero que use CStdioFile. Es muy conveniente usarlo para realizar dichas operaciones, como se muestra en el siguiente ejemplo. .

CStdioFile mFile;

CFileException mExcept;

mFile.Open( "d:\\temp\\aa.bat ", CFile::modeWrite, &mExcept

CString string= "Soy una cadena. ";

mFile.WriteString(string)

mFile.Close(); >

4. Uso de archivos temporales

El software normal suele utilizar archivos temporales. A menudo puede ver una gran cantidad de archivos con la extensión tmp en el directorio C:\Windows\Temp. Estos son los archivos que crea el programa. para ejecutar. El uso de archivos temporales es básicamente el mismo que el de los archivos normales, excepto que el nombre del archivo debe obtenerse llamando a la función GetTempFileName(). Su primer parámetro es la ruta para crear este archivo temporal, el segundo parámetro es el prefijo del nombre del archivo temporal y el cuarto parámetro se usa para obtener el nombre del archivo temporal. Después de obtener el nombre del archivo temporal, puede usarlo para crear y operar archivos, como:

char szTempPath[_MAX_PATH],szTempfile[_MAX_PATH]

GetTempPath(_MAX_PATH, szTempPath;

GetTempFileName(szTempPath,_T ( "my_ "),0,szTempfile);

CFile m_tempFile(szTempfile,CFile:: modeCreate|CFile:: modeWrite < /); p>

char m_char= 'a ';

m_tempFile.Write(&m_char,2);

m_tempFile.Close(); Copiar, eliminar archivos, etc.

MFC no proporciona la función para realizar estas operaciones directamente, por lo que se debe utilizar el SDK. Las funciones relacionadas con archivos más utilizadas en el SDK incluyen CopyFile(), CreateDirectory(), DeleteFile() y MoveFile(). Su uso es muy simple, consulte MSDN.

********************************************* *** ************************************************* **** *****

XXXXXXXXXXXXXXXXXXXXXX ×××××××××××

*************** ******************* ******************************* ********************** ****************

Cómo realizar operaciones con archivos

[1] Muestra el cuadro de diálogo y obtiene el nombre del archivo

CString FilePathName

CFileDialog dlg(TRUE);///TRUE es el cuadro de diálogo ABRIR, FALSO es el cuadro de diálogo GUARDAR COMO

if (dlg.DoModal() == IDOK)

FilePathName=dlg.GetPathName()

Información relacionada: CFileDialog tiene varias funciones miembro para obtener nombres de archivos:

Si el archivo seleccionado es C :\WINDOWS\TEST.EXE

Entonces (1) GetPathName(); archivo, incluida la ruta completa.

Recuperar C:\WINDOWS\TEST.EXE

(2)GetFileTitle(); Obtener el nombre completo del archivo: TEST.EXE

(3)GetFileName();

(4)GetFileExt(); Obtener la extensión EXE

[2]Abrir el archivo

Archivo CFile( "C:\HELLO.TXT ", CFile: :modeRead);//Abrir en modo de solo lectura

//CFile::modeRead se puede cambiar a CFile::modeWrite(solo escritura),

// CFile::modeReadWrite(leer Escritura), CFile::modeCreate(nuevo)

Ejemplo:

{

Archivo CFile; file.Open( "C :\HOLA.TXT ",CFile::modeCreate|Cfile::modeWrite

. p>

}

[3]Mover el puntero del archivo

file.Seek(100,CFile::begin ///Bajar 100 bytes desde el principio de); el archivo

file.Seek(-50,CFile::end);///Subir 50 bytes desde el final del archivo

file.Seek(-30,CFile ::current);/// Subir 30 bytes desde la posición actual

file.SeekToBegin();///Mover al principio del archivo

file.SeekToEnd( );///Mover al final del archivo

[4]Leer y escribir archivos

Leer archivos:

char buffer[1000]; /p>

file.Read(buffer,1000)

Escribir archivo:

CString string("Esforzarse continuamente por la superación personal"); p>file.Write(string,8);

[ 5]Cerrar el archivo

file.Close();

Además, la máquina virtual la compra grupal de productos es super barata