QFile Class
La clase QFile ofrece una interfaz para leer y escribir en archivos. Más información...
| Encabezado: | #include <QFile> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Heredado de: | QFileDevice |
| Heredado por: |
- Lista de todos los miembros, incluidos los heredados
- QFile forma parte de Entrada/Salida y Redes.
Nota: Todas las funciones de esta clase son reentrantes.
Funciones públicas
| QFile() | |
| QFile(QObject *parent) | |
| QFile(const QString &name) | |
(since 6.0) | QFile(const std::filesystem::path &name) |
| QFile(const QString &name, QObject *parent) | |
(since 6.0) | QFile(const std::filesystem::path &name, QObject *parent) |
| virtual | ~QFile() |
| bool | copy(const QString &newName, std::optional<QFileDevice::Permissions> perm = std::nullopt) |
(since 6.0) bool | copy(const std::filesystem::path &newName) |
| bool | exists() const |
(since 6.0) std::filesystem::path | filesystemFileName() const |
(since 6.3) std::filesystem::path | filesystemSymLinkTarget() const |
| bool | link(const QString &linkName) |
(since 6.0) bool | link(const std::filesystem::path &newName) |
| bool | moveToTrash() |
(since 6.3) bool | open(QIODeviceBase::OpenMode mode, QFileDevice::Permissions permissions) |
| bool | open(FILE *fh, QIODeviceBase::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle) |
| bool | open(int fd, QIODeviceBase::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle) |
| bool | remove() |
| bool | rename(const QString &newName) |
(since 6.0) bool | rename(const std::filesystem::path &newName) |
| void | setFileName(const QString &name) |
(since 6.0) void | setFileName(const std::filesystem::path &name) |
| QString | symLinkTarget() const |
Funciones públicas reimplementadas
| virtual QString | fileName() const override |
| virtual bool | open(QIODeviceBase::OpenMode mode) override |
| virtual QFileDevice::Permissions | permissions() const override |
| virtual bool | resize(qint64 sz) override |
| virtual bool | setPermissions(QFileDevice::Permissions permissions) override |
| virtual qint64 | size() const override |
Miembros públicos estáticos
| bool | copy(const QString &fileName, const QString &newName, std::optional<QFileDevice::Permissions> perm = std::nullopt) |
| QString | decodeName(const QByteArray &localFileName) |
| QString | decodeName(const char *localFileName) |
| QByteArray | encodeName(const QString &fileName) |
| bool | exists(const QString &fileName) |
(since 6.3) std::filesystem::path | filesystemSymLinkTarget(const std::filesystem::path &fileName) |
| bool | link(const QString &fileName, const QString &linkName) |
| bool | moveToTrash(const QString &fileName, QString *pathInTrash = nullptr) |
| QFileDevice::Permissions | permissions(const QString &fileName) |
(since 6.0) QFileDevice::Permissions | permissions(const std::filesystem::path &filename) |
| bool | remove(const QString &fileName) |
| bool | rename(const QString &oldName, const QString &newName) |
| bool | resize(const QString &fileName, qint64 sz) |
| bool | setPermissions(const QString &fileName, QFileDevice::Permissions permissions) |
(since 6.0) bool | setPermissions(const std::filesystem::path &filename, QFileDevice::Permissions permissionSpec) |
(since 6.9) bool | supportsMoveToTrash() |
| QString | symLinkTarget(const QString &fileName) |
Descripción detallada
QFile es un dispositivo de E/S para leer y escribir archivos y recursos de texto y binarios. Un QFile puede utilizarse por sí solo o, lo que resulta más práctico, junto con un ` QTextStream ` o un ` QDataStream`.
El nombre del archivo suele pasarse en el constructor, pero puede establecerse en cualquier momento mediante setFileName(). QFile espera que el separador de archivos sea «/», independientemente del sistema operativo. No se admite el uso de otros separadores (por ejemplo, «\»).
Puedes comprobar si un archivo existe utilizando exists(), y eliminar un archivo utilizando remove(). ( QFileInfo y QDir proporcionan operaciones más avanzadas relacionadas con el sistema de archivos.)
El archivo se abre con ` open()`, se cierra con ` close()` y se vacía con ` flush()`. Los datos suelen leerse y escribirse utilizando QDataStream o QTextStream, pero también se pueden llamar las funciones heredadas de QIODevice: read(), readLine(), readAll() y write(). QFile también hereda getChar(), putChar() y ungetChar(), que funcionan carácter a carácter.
size() devuelve el tamaño del archivo. Puedes obtener la posición actual en el archivo mediante pos(), o desplazarte a una nueva posición en el archivo utilizando seek(). Si has llegado al final del archivo, atEnd() devuelve true.
Lectura directa de archivos
El siguiente ejemplo lee un archivo de texto línea por línea:
QFile file("in.txt");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
while (!file.atEnd()) {
QByteArray line = file.readLine();
process_line(line);
}El indicador « Text » pasado a « open()» indica a Qt que convierta los terminadores de línea al estilo de Windows («\r\n ») en terminadores al estilo de C++ («\n »). Por defecto, QFile asume que el archivo es binario, es decir, no realiza ninguna conversión sobre los bytes almacenados en el archivo.
Uso de flujos para leer archivos
El siguiente ejemplo utiliza ` QTextStream ` para leer un archivo de texto línea por línea:
QFile file("in.txt");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream in(&file);
while (!in.atEnd()) {
QString line = in.readLine();
process_line(line);
}QTextStream se encarga de convertir los datos de 8 bits almacenados en el disco a un QString Unicode de 16 bits. Por defecto, se asume que el archivo está codificado en UTF-8. Esto se puede cambiar utilizando QTextStream::setEncoding().
Para escribir texto, podemos utilizar el operador <<(), que está sobrecargado para aceptar un QTextStream a la izquierda y varios tipos de datos (incluido QString) a la derecha:
QFile file("out.txt");
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
return;
QTextStream out(&file);
out << "The magic number is: " << 49 << "\n";QDataStream es similar, en el sentido de que se puede utilizar el operador <<() para escribir datos y el operador >>() para leerlos de nuevo. Consulta la documentación de la clase para obtener más detalles.
Señales
A diferencia de otras implementaciones de ` QIODevice `, como ` QTcpSocket`, `QFile` no emite las señales ` aboutToClose()`, ` bytesWritten()` ni ` readyRead()`. Este detalle de la implementación implica que `QFile` no es adecuado para leer y escribir determinados tipos de archivos, como los archivos de dispositivo en plataformas Unix.
Cuestiones específicas de cada plataforma
Las API de Qt relacionadas con la E/S utilizan QStrings basadas en UTF-16 para representar las rutas de los archivos. Sin embargo, las API estándar de C++ (<cstdio> o <iostream>) o las API específicas de cada plataforma suelen necesitar una ruta codificada en 8 bits. Puedes utilizar encodeName() y decodeName() para convertir entre ambas representaciones.
En Unix, hay algunos archivos de sistema especiales (por ejemplo, en /proc) para los que size() siempre devolverá 0, aunque es posible que aún puedas leer más datos de dicho archivo; los datos se generan como respuesta directa a la llamada a read(). En este caso, sin embargo, no se puede utilizar atEnd() para determinar si hay más datos que leer (ya que atEnd() devolverá «true» para un archivo que indique tener un tamaño de 0). En su lugar, se debe llamar a readAll(), o bien a read() o a readLine() repetidamente hasta que no se puedan leer más datos. El siguiente ejemplo utiliza QTextStream para leer /proc/modules línea por línea:
QFile file("/proc/modules");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return;
QTextStream in(&file);
QString line = in.readLine();
while (!line.isNull()) {
process_line(line);
line = in.readLine();
}En Android, existen algunas limitaciones a la hora de gestionar los URI de contenido:
- Es posible que se necesiten permisos de acceso, para lo cual se debe solicitar al usuario a través de QFileDialog, que implementa el selector de archivos nativo de Android.
- Procura seguir las directrices de almacenamiento con ámbito, como utilizar directorios específicos de la aplicación en lugar de otros directorios externos públicos. Para obtener más información, consulta también las prácticas recomendadas de almacenamiento.
- Debido al diseño de las API de Qt (por ejemplo, QFile), no es posible integrar completamente estas últimas API con las API de MediaStore de Android.
Consideraciones de seguridad
Normalización de rutas de Windows
Las API de Qt que gestionan rutas de archivos y directorios realizan la normalización y la canonicización de forma diferente a las API nativas de Windows:
- No se eliminan los puntos ni los espacios en blanco al final.
- Los nombres cortos 8.3 no se amplían.
- Los prefijos «
\\?\» y «\\?\UNC\» siempre se descartan.
Estas diferencias abren la posibilidad de eludir los controles de seguridad basados en la comparación de cadenas o la coincidencia de patrones. Por ejemplo, el código siguiente dará como resultado « false » en ambas comparaciones, pero al pasar esta ruta a QFile se abrirá correctamente « myapp.exe » en « Program Files ».
const QString path = u"C:\\PROGRA~1\\MyApp\\myapp.exe."_s; // fíjate en el punto final
QFileInfo fi(path);
qDebug() << fi.canonicalFilePath().contains("Program Files"_L1); // false
qDebug() << (fi.suffix() == "exe"_L1); // false
QFile f(path);
f.open(QIODevice::WriteOnly); // truePermisos de los archivos
Los permisos de los archivos se gestionan de forma diferente en los sistemas tipo Unix y en Windows. En un directorio sin permiso de escritura ( writable ) en sistemas tipo Unix, no se pueden crear archivos. Esto no siempre es así en Windows, donde, por ejemplo, el directorio «Mis documentos» no suele ser de escritura, pero aún así es posible crear archivos en él.
La gestión de los permisos de archivo por parte de Qt es limitada, lo que afecta especialmente a la función QFile::setPermissions(). En Windows, Qt solo establecerá el indicador heredado de «solo lectura», y solo cuando no se pase ninguno de los indicadores Write*. Qt no manipula las listas de control de acceso (ACL), lo que hace que esta función sea prácticamente inútil para los volúmenes NTFS. No obstante, puede resultar útil para memorias USB que utilicen sistemas de archivos VFAT. Tampoco se manipulan las ACL de POSIX.
Véase también QTextStream, QDataStream, QFileInfo, QDir y El sistema de recursos de Qt.
Documentación de las funciones miembro
QFile::QFile()
Crea un objeto QFile.
[explicit] QFile::QFile(QObject *parent)
Crea un nuevo objeto de archivo con el ` parent` indicado.
[explicit] QFile::QFile(const QString &name)
Crea un nuevo objeto de archivo para representar el archivo con el name indicado.
Nota: En las versiones hasta Qt 6.8, ambas incluidas, este constructor es implícito, por motivos de compatibilidad con versiones anteriores. A partir de Qt 6.9, este constructor es incondicionalmente explicit. Los usuarios pueden forzar que este constructor sea explicit incluso en versiones anteriores de Qt definiendo la macro QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH antes de incluir cualquier encabezado de Qt.
[explicit, since 6.0] QFile::QFile(const std::filesystem::path &name)
Crea un nuevo objeto de archivo para representar el archivo con la dirección « name » indicada.
Nota: En las versiones hasta Qt 6.8, ambas incluidas, este constructor es implícito, por motivos de compatibilidad con versiones anteriores. A partir de Qt 6.9, este constructor es incondicionalmente explicit. Los usuarios pueden forzar que este constructor sea explicit incluso en versiones anteriores de Qt definiendo la macro QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH antes de incluir cualquier encabezado de Qt.
Esta función se introdujo en Qt 6.0.
QFile::QFile(const QString &name, QObject *parent)
Crea un nuevo objeto de archivo con el ` parent ` proporcionado para representar el archivo con el ` name` especificado.
[since 6.0] QFile::QFile(const std::filesystem::path &name, QObject *parent)
Crea un nuevo objeto de archivo con el « parent » proporcionado para representar el archivo con el « name » especificado.
Esta función se introdujo en Qt 6.0.
[virtual noexcept] QFile::~QFile()
Destruye el objeto de archivo, cerrándolo si es necesario.
bool QFile::copy(const QString &newName, std::optional<QFileDevice::Permissions> perm = std::nullopt)
Copia el archivo llamado « fileName » () en « newName ».
Este archivo se cierra antes de copiarlo.
Desde Qt 6.12, se pueden especificar los permisos perm al llamar a la función. Si no se pasan, se copian los permisos del archivo original. El nuevo archivo se creará con los permisos indicados.
Si el archivo copiado es un enlace simbólico (symlink), se copia el archivo al que hace referencia, no el propio enlace. A excepción de los permisos, no se copia ningún otro metadato del archivo.
Devuelve ` true ` si se realiza correctamente; en caso contrario, devuelve ` false`.
Ten en cuenta que, si ya existe un archivo con el nombre newName, copy() devuelve false. Esto significa que QFile no lo sobrescribirá. Sin embargo, la operación no es atómica. Existe la posibilidad de que otro proceso cree un archivo con newName entre la comprobación y la copia. En tal caso, el archivo se sobrescribirá.
Nota: En Android, esta operación aún no es compatible con las URI del esquema content.
Véase también setFileName().
[since 6.0] bool QFile::copy(const std::filesystem::path &newName)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[static] bool QFile::copy(const QString &fileName, const QString &newName, std::optional<QFileDevice::Permissions> perm = std::nullopt)
Copia el archivo denominado « fileName » en « newName ».
Desde Qt 6.12, se pueden especificar los permisos perm al llamar a la función. Si no se pasan, se copian los permisos del archivo original. El nuevo archivo se creará con los permisos indicados.
Si el archivo copiado es un enlace simbólico (symlink), se copia el archivo al que hace referencia, no el enlace en sí. A excepción de los permisos, no se copia ningún otro metadato del archivo.
Devuelve « true » si la operación se realiza correctamente; en caso contrario, devuelve « false ».
Ten en cuenta que, si ya existe un archivo con el nombre newName, copy() devuelve false. Esto significa que QFile no lo sobrescribirá. Sin embargo, la operación no es atómica. Existe la posibilidad de que otro proceso cree un archivo con newName entre la comprobación y la copia. En tal caso, el archivo se sobrescribirá.
Nota: En Android, esta operación aún no es compatible con las URI del esquema content.
Esta es una función sobrecargada.
Véase también rename().
[static] QString QFile::decodeName(const QByteArray &localFileName)
Esto hace lo contrario de lo que hace QFile::encodeName() utilizando localFileName.
Véase también encodeName().
[static] QString QFile::decodeName(const char *localFileName)
Devuelve la versión Unicode del ` localFileName` indicado. Consulta ` encodeName()` para obtener más detalles.
Esta es una función sobrecargada.
[static] QByteArray QFile::encodeName(const QString &fileName)
Convierte « fileName » a una codificación de 8 bits que se puede utilizar en las API nativas. En Windows, la codificación es la de la página de códigos activa de Windows (ANSI). En otras plataformas, es UTF-8; en el caso de macOS, en forma descompuesta (NFD).
Véase también decodeName().
[static] bool QFile::exists(const QString &fileName)
Devuelve ` true ` si existe el archivo especificado por ` fileName `; en caso contrario, devuelve ` false`.
Nota: Si fileName es un enlace simbólico que apunta a un archivo que no existe, se devuelve false.
bool QFile::exists() const
Devuelve « true » si existe el archivo especificado por « fileName()»; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también fileName() y setFileName().
[override virtual] QString QFile::fileName() const
Reimplementa: ` QFileDevice::fileName()` const.
Devuelve el nombre del archivo tal y como se ha establecido mediante setFileName(), rename() o mediante los constructores QFile.
Véase también setFileName(), rename() y QFileInfo::fileName().
[since 6.0] std::filesystem::path QFile::filesystemFileName() const
Devuelve ` fileName()` como ` std::filesystem::path`.
Esta función se introdujo en Qt 6.0.
[since 6.3] std::filesystem::path QFile::filesystemSymLinkTarget() const
Devuelve ` symLinkTarget()` como ` std::filesystem::path`.
Esta función se introdujo en Qt 6.3.
[static, since 6.3] std::filesystem::path QFile::filesystemSymLinkTarget(const std::filesystem::path &fileName)
Devuelve symLinkTarget() como un objeto de tipo std::filesystem::path de fileName.
Esta función se introdujo en Qt 6.3.
bool QFile::link(const QString &linkName)
Crea un enlace denominado « linkName » que apunta al archivo especificado actualmente por « fileName()». La naturaleza de este enlace depende del sistema de archivos subyacente (ya sea un acceso directo en Windows o un enlace simbólico en Unix). Devuelve « true » si la operación se realiza con éxito; en caso contrario, devuelve « false ».
Esta función no sobrescribirá una entidad ya existente en el sistema de archivos; en este caso, ` link() ` devolverá `false` y configurará ` error()` para que devuelva ` RenameError`.
Nota: Para crear un enlace válido en Windows, linkName debe tener la extensión de archivo .lnk.
Véase también setFileName().
[since 6.0] bool QFile::link(const std::filesystem::path &newName)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[static] bool QFile::link(const QString &fileName, const QString &linkName)
Crea un enlace llamado « linkName » que apunta al archivo « fileName ». La naturaleza de este enlace depende del sistema de archivos subyacente (ya sea un acceso directo en Windows o un enlace simbólico en Unix). Devuelve « true » si se realiza correctamente; en caso contrario, devuelve « false ».
Esta es una función sobrecargada.
Véase también link().
bool QFile::moveToTrash()
Mueve el archivo especificado por ` fileName()` a la papelera. Devuelve ` true ` si la operación se realiza correctamente, y establece ` fileName()` en la ruta en la que se puede encontrar el archivo dentro de la papelera; en caso contrario, devuelve ` false`.
El tiempo de ejecución de esta función es independiente del tamaño del archivo que se va a enviar a la papelera. Si se invoca esta función sobre un directorio, puede ser proporcional al número de archivos que se van a enviar a la papelera. Si el objeto ` fileName()` actual apunta a un enlace simbólico, esta función trasladará el enlace a la papelera —lo que podría romperlo— y no el destino del enlace.
Esta función utiliza las API de Windows y macOS para realizar el envío a la papelera en esos dos sistemas operativos. En el resto de sistemas (sistemas Unix), esta función implementa la especificación de la papelera de FreeDesktop.org, versión 1.0.
Nota: Al utilizar la implementación de la Papelera de FreeDesktop.org, esta función fallará si no puede mover los archivos a la ubicación de la papelera mediante el renombramiento de archivos y enlaces duros. Esta situación se produce si el archivo que se va a enviar a la papelera reside en un volumen (punto de montaje) en el que el usuario actual no tiene permiso para crear el directorio .Trash, o bien en determinados tipos o configuraciones inusuales de sistemas de archivos (como subvolúmenes que no son en sí mismos puntos de montaje).
Nota: En sistemas en los que la API del sistema no informa de la ubicación del archivo en la papelera, fileName() se establecerá en la cadena nula una vez que el archivo se haya movido. En sistemas que no disponen de papelera, esta función siempre devuelve false (véase supportsMoveToTrash()).
Véanse también supportsMoveToTrash(), remove() y QDir::remove().
[static] bool QFile::moveToTrash(const QString &fileName, QString *pathInTrash = nullptr)
Mueve el archivo especificado por ` fileName ` a la papelera. Devuelve ` true ` si se realiza correctamente, y establece ` pathInTrash ` (si se ha proporcionado) con la ruta en la que se puede encontrar el archivo dentro de la papelera; en caso contrario, devuelve ` false`.
El tiempo de ejecución de esta función es independiente del tamaño del archivo que se va a enviar a la papelera. Si esta función se invoca sobre un directorio, puede ser proporcional al número de archivos que se envían a la papelera. Si el fileName() actual apunta a un enlace simbólico, esta función moverá el enlace a la papelera, lo que podría romperlo, pero no el destino del enlace.
Esta función utiliza las API de Windows y macOS para realizar el envío a la papelera en esos dos sistemas operativos. En el resto de sistemas (sistemas Unix), esta función implementa la especificación «FreeDesktop.org Trash» versión 1.0.
Nota: Al utilizar la implementación de la papelera de FreeDesktop.org, esta función fallará si no puede mover los archivos a la ubicación de la papelera mediante el renombramiento de archivos y enlaces duros. Esta situación se produce si el archivo que se va a enviar a la papelera reside en un volumen (punto de montaje) en el que el usuario actual no tiene permiso para crear el directorio .Trash, o bien en determinados tipos o configuraciones inusuales de sistemas de archivos (como subvolúmenes que no son en sí mismos puntos de montaje).
Nota: En los sistemas en los que la API del sistema no informa de la ruta del archivo en la papelera, pathInTrash se establecerá en la cadena nula una vez que el archivo se haya movido. En los sistemas que no disponen de papelera, esta función siempre devuelve «false».
Esta es una función sobrecargada.
[override virtual] bool QFile::open(QIODeviceBase::OpenMode mode)
Reimplementa: QIODevice::open(modo QIODeviceBase::OpenMode).
Abre el archivo utilizando los indicadores de « mode » y devuelve « true » si la operación se realiza correctamente; en caso contrario, devuelve « false ».
Los indicadores para « mode » deben incluir « QIODeviceBase::ReadOnly », « WriteOnly » o « ReadWrite ». También puede incluir indicadores adicionales, como « Text » y « Unbuffered ».
Nota: En los modos WriteOnly o ReadWrite, si el archivo en cuestión aún no existe, esta función intentará crear un nuevo archivo antes de abrirlo. El archivo se creará con el modo 0666 enmascarado por la umask en sistemas POSIX, y con permisos heredados del directorio padre en Windows. En Android, se espera que se tenga permiso de acceso al directorio padre del nombre del archivo; de lo contrario, no será posible crear este archivo inexistente.
Véase también QT_USE_NODISCARD_FILE_OPEN y setFileName().
[since 6.3] bool QFile::open(QIODeviceBase::OpenMode mode, QFileDevice::Permissions permissions)
Si el archivo no existe y « mode » implica crearlo, se creará con los permisos especificados en « permissions ».
En sistemas POSIX, los permisos reales se ven afectados por el valor de ` umask`.
En Windows, los permisos se emulan mediante ACL. Estas ACL pueden aparecer en un orden no canónico cuando al grupo se le conceden menos permisos que a otros. Los archivos y directorios con dichos permisos generarán advertencias al abrir la pestaña «Seguridad» del cuadro de diálogo «Propiedades». Conceder al grupo todos los permisos otorgados a otros evita dichas advertencias.
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.3.
Véase también QIODevice::OpenMode, setFileName() y QT_USE_NODISCARD_FILE_OPEN.
bool QFile::open(FILE *fh, QIODeviceBase::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle)
Abre el identificador de archivo existente « fh » en la ruta indicada « mode ». Se puede utilizar « handleFlags » para especificar opciones adicionales. Devuelve « true » si la operación se realiza correctamente; en caso contrario, devuelve « false ».
Ejemplo:
#include <stdio.h>
void printError(const char* msg)
{
QFile file;
file.open(stderr, QIODevice::WriteOnly);
file.write(msg, qstrlen(msg)); // write to stderr
file.close();
}Cuando se abre un « QFile » mediante esta función, el comportamiento de « close()» viene determinado por el indicador «AutoCloseHandle». Si se especifica «AutoCloseHandle» y esta función se ejecuta correctamente, al llamar a « close()» se cierra el identificador adoptado. De lo contrario, « close()» no cierra realmente el archivo, sino que solo vacía su contenido.
Advertencia:
- Si ` fh ` no hace referencia a un archivo normal —por ejemplo, si es `
stdin`, `stdout` o `stderr`—, es posible que no se pueda llamar a ` seek()`. En esos casos, ` size()` devuelve `0`. Consulte ` QIODevice::isSequential()` para obtener más información. - Dado que esta función abre el archivo sin especificar el nombre del mismo, no puedes utilizar este ` QFile ` con un ` QFileInfo`.
Nota para la plataforma Windows
fh debe abrirse en modo binario (es decir, la cadena de modo debe contener «b», como en «rb» o «wb») al acceder a archivos y otros dispositivos de acceso aleatorio. Qt traducirá los caracteres de fin de línea si se pasa QIODevice::Text a ` mode`. Los dispositivos secuenciales, como `stdin` y `stdout`, no se ven afectados por esta limitación.
Debes habilitar la compatibilidad con aplicaciones de consola para poder utilizar los flujos stdin, stdout y stderr en la consola. Para ello, añade la siguiente declaración al archivo de proyecto de tu aplicación:
CONFIG += consoleEsta es una función sobrecargada.
Véase también ` close()` y ` QT_USE_NODISCARD_FILE_OPEN`.
bool QFile::open(int fd, QIODeviceBase::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle)
Abre el descriptor de archivo existente « fd » en el « mode » indicado. Se puede utilizar « handleFlags » para especificar opciones adicionales. Devuelve « true » si la operación se realiza correctamente; en caso contrario, devuelve « false ».
Cuando se abre un QFile mediante esta función, el comportamiento de close() viene determinado por el indicador AutoCloseHandle. Si se especifica AutoCloseHandle y esta función se ejecuta correctamente, al llamar a close() se cierra el identificador adoptado. De lo contrario, close() no cierra realmente el archivo, sino que solo vacía su contenido.
Advertencia: Si fd no es un archivo normal, por ejemplo, si es 0 (stdin), 1 (stdout) o 2 (stderr), es posible que no puedas llamar a seek(). En esos casos, size() devuelve 0. Consulta QIODevice::isSequential() para obtener más información.
Advertencia: Dado que esta función abre el archivo sin especificar el nombre del mismo, no se puede utilizar esta QFile con un QFileInfo.
Esta es una función sobrecargada.
Véase también close() y QT_USE_NODISCARD_FILE_OPEN.
[override virtual] QFileDevice::Permissions QFile::permissions() const
Reimplementa: QFileDevice::permissions() const.
Véase también setPermissions().
[static] QFileDevice::Permissions QFile::permissions(const QString &fileName)
Devuelve la combinación completa, unida mediante la operación «OR», de QFile::Permission para fileName.
Esta es una función sobrecargada.
[static, since 6.0] QFileDevice::Permissions QFile::permissions(const std::filesystem::path &filename)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
bool QFile::remove()
Elimina el archivo especificado por ` fileName()`.
Devuelve true si el archivo se ha eliminado correctamente; en caso contrario, devuelve false.
El archivo se cierra antes de eliminarlo, si estaba abierto.
Véase también setFileName().
[static] bool QFile::remove(const QString &fileName)
Elimina el archivo especificado por el fileName proporcionado.
Devuelve ` true ` si el archivo se ha eliminado correctamente; en caso contrario, devuelve ` false`.
Esta es una función sobrecargada.
Véase también remove().
bool QFile::rename(const QString &newName)
Cambia el nombre del archivo especificado actualmente por ` fileName()` a ` newName`. Devuelve ` true ` si se realiza correctamente; en caso contrario, devuelve ` false`.
Si ya existe un archivo con el nombre newName, rename() devuelve false (es decir, QFile no lo sobrescribirá).
El archivo se cierra antes de cambiarle el nombre.
Si la operación de renombrado falla, Qt intentará copiar el contenido de este archivo a newName y, a continuación, eliminará este archivo, conservando únicamente newName. Si esa operación de copia falla o este archivo no se puede eliminar, se elimina el archivo de destino newName para restaurar el estado anterior.
Véase también setFileName().
[since 6.0] bool QFile::rename(const std::filesystem::path &newName)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[static] bool QFile::rename(const QString &oldName, const QString &newName)
Cambia el nombre del archivo « oldName » por « newName ». Devuelve « true » si la operación se realiza correctamente; en caso contrario, devuelve « false ».
Si ya existe un archivo con el nombre « newName », la función «rename()» devuelve « false » (es decir, « QFile » no lo sobrescribirá).
Esta es una función sobrecargada.
Véase también rename().
[override virtual] bool QFile::resize(qint64 sz)
Reimplementa: QFileDevice::resize(qint64 sz).
[static] bool QFile::resize(const QString &fileName, qint64 sz)
Establece el tamaño de « fileName » (en bytes) en « sz ». Devuelve « true » si el cambio de tamaño se realiza correctamente; «false» en caso contrario. Si « sz » es mayor que el tamaño actual de « fileName », los nuevos bytes se establecerán en 0; si « sz » es menor, el archivo simplemente se trunca.
Advertencia: Esta función puede fallar si el archivo no existe.
Esta es una función sobrecargada.
Véase también ` resize()`.
void QFile::setFileName(const QString &name)
Establece el nombre del archivo ( name ). El nombre puede no incluir ninguna ruta, ser una ruta relativa o una ruta absoluta.
No llames a esta función si el archivo ya está abierto.
Si el nombre del archivo no tiene ruta o tiene una ruta relativa, la ruta utilizada será la del directorio actual de la aplicación en el momento de la llamada a open().
Ejemplo:
QFile file;
QDir::setCurrent("/tmp");
file.setFileName("readme.txt");
QDir::setCurrent("/home");
file.open(QIODevice::ReadOnly); // opens "/home/readme.txt" under UnixTen en cuenta que el separador de directorios «/» funciona en todos los sistemas operativos compatibles con Qt.
Véase también fileName(), QFileInfo y QDir.
[since 6.0] void QFile::setFileName(const std::filesystem::path &name)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[override virtual] bool QFile::setPermissions(QFileDevice::Permissions permissions)
Reimplementa: QFileDevice::setPermissions(permisos de QFileDevice::Permissions).
Establece los permisos del archivo según el permissions especificado. Devuelve true si se realiza correctamente, o false si no es posible modificar los permisos.
Advertencia: Esta función no manipula las ACL, lo que puede limitar su eficacia.
Véase también permissions() y setFileName().
[static] bool QFile::setPermissions(const QString &fileName, QFileDevice::Permissions permissions)
Establece los permisos de un archivo « fileName » en « permissions ».
Esta es una función sobrecargada.
[static, since 6.0] bool QFile::setPermissions(const std::filesystem::path &filename, QFileDevice::Permissions permissionSpec)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[override virtual] qint64 QFile::size() const
Reimplementa: ` QFileDevice::size()` const.
[static, since 6.9] bool QFile::supportsMoveToTrash()
Devuelve ` true ` si Qt admite el traslado de archivos a la papelera de reciclaje en el sistema operativo actual mediante la función ` moveToTrash()`, y ` false ` en caso contrario. Ten en cuenta que el hecho de que esta función devuelva ` true ` no implica que la función ` moveToTrash()` vaya a tener éxito. En concreto, esta función no comprueba si el usuario ha desactivado esta funcionalidad en su configuración.
Esta función se introdujo en Qt 6.9.
Véase también moveToTrash().
[static] QString QFile::symLinkTarget(const QString &fileName)
Devuelve la ruta absoluta del archivo o directorio al que hace referencia el enlace simbólico (o acceso directo en Windows) especificado por ` fileName`, o devuelve una cadena vacía si ` fileName ` no corresponde a un enlace simbólico.
Es posible que este nombre no represente un archivo existente; se trata únicamente de una cadena. QFile::exists() devuelve true si el enlace simbólico apunta a un archivo existente.
QString QFile::symLinkTarget() const
Devuelve la ruta absoluta del archivo o directorio al que apunta un enlace simbólico (o un acceso directo en Windows), o una cadena vacía si el objeto no es un enlace simbólico.
Es posible que este nombre no represente un archivo existente; se trata únicamente de una cadena. QFile::exists() devuelve true si el enlace simbólico apunta a un archivo existente.
Esta es una función sobrecargada.
Véase también fileName() y setFileName().
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.