Sur cette page

QFileDevice Class

La classe QFileDevice fournit une interface permettant de lire et d'écrire dans des fichiers ouverts. En savoir plus...

En-tête : #include <QFileDevice>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Hérite de : QIODevice
Hérité par :

QFile et QSaveFile

Remarque : toutes les fonctions de cette classe sont réentrantes.

Types publics

enum FileError { NoError, ReadError, WriteError, FatalError, ResourceError, …, CopyError }
enum FileHandleFlag { AutoCloseHandle, DontCloseHandle }
flags FileHandleFlags
enum FileTime { FileAccessTime, FileBirthTime, FileMetadataChangeTime, FileModificationTime }
enum MemoryMapFlag { NoOptions, MapPrivateOption }
flags MemoryMapFlags
enum Permission { ReadOwner, WriteOwner, ExeOwner, ReadUser, WriteUser, …, ExeOther }
flags Permissions

Fonctions publiques

virtual ~QFileDevice()
QFileDevice::FileError error() const
virtual QString fileName() const
QDateTime fileTime(QFileDevice::FileTime time) const
bool flush()
int handle() const
uchar *map(qint64 offset, qint64 size, QFileDevice::MemoryMapFlags flags = NoOptions)
virtual QFileDevice::Permissions permissions() const
virtual bool resize(qint64 sz)
bool setFileTime(const QDateTime &newDate, QFileDevice::FileTime fileTime)
virtual bool setPermissions(QFileDevice::Permissions permissions)
bool unmap(uchar *address)
void unsetError()

Fonctions publiques réimplémentées

virtual bool atEnd() const override
virtual void close() override
virtual bool isSequential() const override
virtual qint64 pos() const override
virtual bool seek(qint64 pos) override
virtual qint64 size() const override

Fonctions protégées réimplémentées

virtual qint64 readData(char *data, qint64 len) override
virtual qint64 readLineData(char *data, qint64 maxlen) override
virtual qint64 writeData(const char *data, qint64 len) override

Macros

Description détaillée

QFileDevice est la classe de base des périphériques d'E/S capables de lire et d'écrire des fichiers et des ressources textuels et binaires. QFile offre les fonctionnalités principales ; QFileDevice sert de classe de base pour partager ces fonctionnalités avec d'autres périphériques de fichiers tels que QSaveFile, en fournissant toutes les opérations pouvant être effectuées sur des fichiers ouverts par QFile ou QSaveFile.

Voir également QFile et QSaveFile.

Documentation sur les types de membres

enum QFileDevice::FileError

Cette énumération décrit les erreurs pouvant être renvoyées par la fonction error().

ConstanteValeurDescription
QFileDevice::NoError0Aucune erreur ne s'est produite.
QFileDevice::ReadError1Une erreur s'est produite lors de la lecture du fichier.
QFileDevice::WriteError2Une erreur s'est produite lors de l'écriture dans le fichier.
QFileDevice::FatalError3Une erreur fatale s'est produite.
QFileDevice::ResourceError4Ressources insuffisantes (par exemple, trop de fichiers ouverts, mémoire insuffisante, etc.)
QFileDevice::OpenError5Impossible d'ouvrir le fichier.
QFileDevice::AbortError6L'opération a été interrompue.
QFileDevice::TimeOutError7Un délai d'attente a expiré.
QFileDevice::UnspecifiedError8Une erreur non spécifiée s'est produite.
QFileDevice::RemoveError9Le fichier n'a pas pu être supprimé.
QFileDevice::RenameError10Le fichier n'a pas pu être renommé.
QFileDevice::PositionError11Impossible de modifier la position dans le fichier.
QFileDevice::ResizeError12Le fichier n'a pas pu être redimensionné.
QFileDevice::PermissionsError13L'accès au fichier n'a pas pu être établi.
QFileDevice::CopyError14Le fichier n'a pas pu être copié.

enum QFileDevice::FileHandleFlag
flags QFileDevice::FileHandleFlags

Cette énumération est utilisée lors de l'ouverture d'un fichier pour spécifier des options supplémentaires qui s'appliquent uniquement aux fichiers et non à une opération générique de lecture/écriture ( QIODevice).

ConstanteValeurDescription
QFileDevice::AutoCloseHandle0x0001Le descripteur de fichier passé à ` open()` doit être fermé par ` close()` ; par défaut, la fonction `close` se contente de vider le fichier et il incombe à l’application de fermer le descripteur de fichier. Lors de l’ouverture d’un fichier par son nom, cet indicateur est ignoré car Qt détient toujours le descripteur de fichier et doit le fermer.
QFileDevice::DontCloseHandle0S’il n’est pas explicitement fermé, le descripteur de fichier sous-jacent reste ouvert lorsque l’objet ` QFile ` est détruit.

Le type `FileHandleFlags` est un `typedef` pour ` QFlags<FileHandleFlag>`. Il stocke une combinaison OR de valeurs `FileHandleFlag`.

enum QFileDevice::FileTime

Cette énumération est utilisée par les fonctions fileTime() et setFileTime().

ConstanteValeurDescription
QFileDevice::FileAccessTime0Date du dernier accès au fichier (par exemple, lecture ou écriture).
QFileDevice::FileBirthTime1Date de création du fichier (peut ne pas être prise en charge sous UNIX).
QFileDevice::FileMetadataChangeTime2Date de la dernière modification des métadonnées du fichier.
QFileDevice::FileModificationTime3Date de la dernière modification du fichier.

Voir également setFileTime(), fileTime() et QFileInfo::fileTime().

enum QFileDevice::MemoryMapFlag
flags QFileDevice::MemoryMapFlags

Cette énumération décrit les options spéciales pouvant être utilisées par la fonction map().

ConstanteValeurDescription
QFileDevice::NoOptions0Aucune option.
QFileDevice::MapPrivateOption0x0001La mémoire mappée sera privée ; ainsi, aucune modification ne sera visible par les autres processus et ne sera pas écrite sur le disque. Ces modifications seront perdues lorsque la mémoire sera démappée. Il n’est pas précisé si les modifications apportées au fichier après la création du mappage seront visibles via la mémoire mappée. Cette valeur d’énumération a été introduite dans Qt 5.4.

Le type `MemoryMapFlags` est un `typedef` pour ` QFlags<MemoryMapFlag>`. Il stocke une combinaison OR de valeurs `MemoryMapFlag`.

enum QFileDevice::Permission
flags QFileDevice::Permissions

Cette énumération est utilisée par la fonction permission() pour renvoyer les droits d'accès et le propriétaire d'un fichier. Les valeurs peuvent être combinées à l'aide d'un opérateur OU pour tester plusieurs valeurs de droits d'accès et de propriété.

ConstanteValeurDescription
QFileDevice::ReadOwner0x4000Le fichier est lisible par son propriétaire.
QFileDevice::WriteOwner0x2000Le fichier est accessible en écriture par son propriétaire.
QFileDevice::ExeOwner0x1000Le fichier est exécutable par son propriétaire.
QFileDevice::ReadUser0x0400Le fichier est accessible en lecture par l'utilisateur.
QFileDevice::WriteUser0x0200Le fichier est accessible en écriture par l'utilisateur.
QFileDevice::ExeUser0x0100Le fichier est exécutable par l’utilisateur.
QFileDevice::ReadGroup0x0040Le fichier est lisible par le groupe.
QFileDevice::WriteGroup0x0020Le fichier est modifiable par le groupe.
QFileDevice::ExeGroup0x0010Le fichier est exécutable par le groupe.
QFileDevice::ReadOther0x0004Le fichier est lisible par les autres.
QFileDevice::WriteOther0x0002Le fichier est accessible en écriture par les autres.
QFileDevice::ExeOther0x0001Le fichier est exécutable par les autres utilisateurs.

Avertissement : en raison des différences entre les plateformes prises en charge par Qt, la sémantique des fonctions ReadUser, WriteUser et ExeUser dépend de la plateforme : sous Unix, ce sont les droits du propriétaire du fichier qui sont renvoyés, tandis que sous Windows, ce sont ceux de l’utilisateur actuel. Ce comportement est susceptible de changer dans une future version de Qt.

Remarque : sur les systèmes de fichiers NTFS, la vérification de la propriété et des droits d'accès est désactivée par défaut pour des raisons de performances. Pour l'activer, ajoutez la ligne suivante :

extern Q_CORE_EXPORT int qt_ntfs_permission_lookup;

La vérification des droits d'accès est alors activée ou désactivée en augmentant ou en diminuant la valeur de ` qt_ntfs_permission_lookup ` de 1.

qt_ntfs_permission_lookup++; // turn checking on
qt_ntfs_permission_lookup--; // turn it off again

Remarque : comme il s’agit d’une variable globale non atomique, il n’est sûr d’incrémenter ou de décrémenter ` qt_ntfs_permission_lookup ` qu’avant le démarrage de tout thread autre que le thread principal ou après la fin de tous les threads autres que le thread principal.

Remarque : à partir de Qt 6.6, la variable ` qt_ntfs_permission_lookup ` est obsolète. Veuillez utiliser les alternatives suivantes.

La manière la plus sûre et la plus simple de gérer les vérifications d'autorisation consiste à utiliser la classe RAII ` QNtfsPermissionCheckGuard`.

void complexFunction()
{
    QNtfsPermissionCheckGuard permissionGuard;  // check is enabled

    // do complex things here that need permission check enabled

}   // as the guard goes out of scope the check is disabled

Si vous avez besoin d'un contrôle plus fin, il est possible de gérer les autorisations à l'aide des fonctions suivantes :

qAreNtfsPermissionChecksEnabled();   // vérifier l'état
qEnableNtfsPermissionChecks();       // turn checking on
qDisableNtfsPermissionChecks();      // turn it off again

Le type « Permissions » est un typedef pour QFlags<Permission>. Il stocke une combinaison (ou) de valeurs Permission.

Documentation des fonctions membres

[virtual noexcept] QFileDevice::~QFileDevice()

Détruit le périphérique de fichier, en le fermant si nécessaire.

[override virtual] bool QFileDevice::atEnd() const

Réimplémente : QIODevice::atEnd() const.

Renvoie ` true ` si la fin du fichier a été atteinte ; sinon, renvoie `false`.

Pour les fichiers vides classiques sous Unix (par exemple ceux du répertoire /proc), cette fonction renvoie true, car le système de fichiers indique que la taille d’un tel fichier est égale à 0. Par conséquent, vous ne devez pas vous fier à atEnd() lors de la lecture de données à partir d’un tel fichier, mais plutôt appeler read() jusqu’à ce qu’il n’y ait plus de données à lire.

[override virtual] void QFileDevice::close()

Réimplémente la fonction : ` QIODevice::close()`.

Appelle QFileDevice::flush() et ferme le fichier. Les erreurs générées par la fonction flush sont ignorées.

Voir également QIODevice::close().

QFileDevice::FileError QFileDevice::error() const

Renvoie le statut d'erreur du fichier.

Le statut du périphérique d'E/S renvoie un code d'erreur. Par exemple, si la fonction ` open()` renvoie ` false`, ou si une opération de lecture/écriture renvoie -1, cette fonction peut être appelée pour déterminer la raison de l'échec de l'opération.

Voir également unsetError().

[virtual] QString QFileDevice::fileName() const

Renvoie le nom du fichier. L'implémentation par défaut dans ` QFileDevice ` renvoie une chaîne vide.

QDateTime QFileDevice::fileTime(QFileDevice::FileTime time) const

Renvoie l'heure du fichier spécifiée par time. Si l'heure ne peut pas être déterminée, renvoie QDateTime() (une date et une heure non valides).

Voir également setFileTime(), FileTime et QDateTime::isValid().

bool QFileDevice::flush()

Écrit toutes les données mises en mémoire tampon dans le fichier. Renvoie « true » en cas de succès ; sinon, renvoie « false ».

int QFileDevice::handle() const

Renvoie le descripteur du fichier.

Il s'agit d'un petit entier positif, adapté à une utilisation avec des fonctions de la bibliothèque C telles que ` fdopen() ` et ` fcntl()`. Sur les systèmes qui utilisent des descripteurs de fichiers pour les sockets (c'est-à-dire les systèmes Unix, mais pas Windows), ce descripteur peut également être utilisé avec ` QSocketNotifier `.

Si le fichier n’est pas ouvert ou en cas d’erreur, la fonction handle() renvoie -1.

Voir également QSocketNotifier.

[override virtual] bool QFileDevice::isSequential() const

Réimplémente : QIODevice::isSequential() const.

Renvoie ` true ` si le fichier ne peut être manipulé que de manière séquentielle ; sinon, renvoie ` false`.

La plupart des fichiers prennent en charge l'accès aléatoire, mais certains fichiers spéciaux peuvent ne pas le faire.

Voir également QIODevice::isSequential().

uchar *QFileDevice::map(qint64 offset, qint64 size, QFileDevice::MemoryMapFlags flags = NoOptions)

La fonction ` size ` mappe les octets du fichier en mémoire à partir de l'adresse ` offset`. Pour que la mise en mémoire soit réussie, le fichier doit être ouvert ; toutefois, il n'est pas nécessaire que le fichier reste ouvert une fois la mémoire mappée. Lorsque l'objet ` QFile ` est détruit ou qu'un nouveau fichier est ouvert avec cet objet, toutes les mises en mémoire qui n'ont pas été annulées le seront automatiquement.

Le mappage aura le même mode d’ouverture que le fichier (lecture et/ou écriture), sauf en cas d’utilisation de l’option ` MapPrivateOption`, auquel cas il est toujours possible d’écrire dans la mémoire mappée.

Toutes les options de mappage peuvent être transmises via ` flags`.

Renvoie un pointeur vers la mémoire ou ` nullptr ` en cas d’erreur.

Voir également ` unmap()`.

[virtual] QFileDevice::Permissions QFileDevice::permissions() const

Renvoie la combinaison complète, sous forme d'opération « OU », des QFile::Permission associées au fichier.

Voir aussi setPermissions().

[override virtual] qint64 QFileDevice::pos() const

Réimplémente : QIODevice::pos() const.

[override virtual protected] qint64 QFileDevice::readData(char *data, qint64 len)

Réimplémentation de : QIODevice::readData(char *data, qint64 maxSize).

[override virtual protected] qint64 QFileDevice::readLineData(char *data, qint64 maxlen)

Réimplémente : QIODevice::readLineData(char *data, qint64 maxSize).

[virtual] bool QFileDevice::resize(qint64 sz)

Définit la taille du fichier (en octets) sz. Renvoie true si le redimensionnement réussit ; false dans le cas contraire. Si sz est supérieur à la taille actuelle du fichier, les nouveaux octets seront mis à 0 ; si sz est inférieur, le fichier est simplement tronqué.

Avertissement : cette fonction peut échouer si le fichier n’existe pas.

Voir aussi size().

[override virtual] bool QFileDevice::seek(qint64 pos)

Réimplémente : QIODevice::seek(qint64 pos).

Pour les périphériques à accès aléatoire, cette fonction définit la position courante à pos et renvoie « true » en cas de succès, ou « false » en cas d’erreur. Pour les périphériques séquentiels, le comportement par défaut consiste à ne rien faire et à renvoyer « false ».

Recherche au-delà de la fin d’un fichier : si la position se trouve au-delà de la fin d’un fichier, la fonction seek() n’étendra pas immédiatement le fichier. Si une écriture est effectuée à cette position, le fichier sera alors étendu. Le contenu du fichier situé entre l’ancienne fin du fichier et les données nouvellement écrites est INDÉFINI et varie selon les plateformes et les systèmes de fichiers.

bool QFileDevice::setFileTime(const QDateTime &newDate, QFileDevice::FileTime fileTime)

Définit l'horodatage du fichier spécifié par ` fileTime ` sur ` newDate`, en renvoyant `true` en cas de succès ; sinon, renvoie `false`.

Remarque : le fichier doit être ouvert pour pouvoir utiliser cette fonction.

Voir également fileTime() et FileTime.

[virtual] bool QFileDevice::setPermissions(QFileDevice::Permissions permissions)

Définit les droits d'accès du fichier selon l'permissions spécifiée. Renvoie « true » en cas de succès, ou « false » si les droits d'accès ne peuvent pas être modifiés.

Avertissement : cette fonction ne manipule pas les listes de contrôle d'accès (ACL), ce qui peut limiter son efficacité.

Voir aussi permissions().

[override virtual] qint64 QFileDevice::size() const

Réimplémente : ` QIODevice::size() const`.

Renvoie la taille du fichier.

Pour les fichiers vides classiques sous Unix (par exemple ceux du répertoire /proc), cette fonction renvoie 0 ; le contenu d'un tel fichier est généré à la demande lorsque vous appelez la fonction read().

bool QFileDevice::unmap(uchar *address)

Démappe la mémoire address.

Renvoie true si le démontage réussit ; false dans le cas contraire.

Voir également map().

void QFileDevice::unsetError()

Définit l'erreur du fichier sur « QFileDevice::NoError ».

Voir aussi error().

[override virtual protected] qint64 QFileDevice::writeData(const char *data, qint64 len)

Réimplémente : QIODevice::writeData(const char *data, qint64 maxSize).

Documentation des macros

[since 6.8] QT_NO_USE_NODISCARD_FILE_OPEN

[since 6.8] QT_USE_NODISCARD_FILE_OPEN

Les classes d'E/S liées aux fichiers (telles que QFile, QSaveFile, QTemporaryFile) disposent d'une méthode open() permettant d'ouvrir le fichier sur lequel elles opèrent. Il est important de vérifier la valeur renvoyée par l'appel à open() avant de procéder à la lecture ou à l'écriture de données dans le fichier.

C’est pourquoi, à partir de Qt 6.8, certaines surcharges de ` open() ` ont été marquées avec l’attribut ` [[nodiscard]] `. Étant donné que cette modification peut générer des avertissements dans les bases de code existantes, le code utilisateur peut choisir d’activer ou de désactiver l’application de cet attribut en définissant certaines macros :

  • Si la macro ` QT_USE_NODISCARD_FILE_OPEN ` est définie, les surcharges de ` open() ` sont marquées comme ` [[nodiscard]]`.
  • Si la macro ` QT_NO_USE_NODISCARD_FILE_OPEN ` est définie, les surcharges de ` open() ` ne sont pas marquées comme ` [[nodiscard]]`.
  • Si aucune des deux macros n’est définie, le comportement par défaut jusqu’à Qt 6.9 inclus est de ne pas utiliser cet attribut. À partir de Qt 6.10, l’attribut est automatiquement appliqué.
  • Si les deux macros sont définies, le programme est mal formé.

Ces macros ont été introduites dans Qt 6.8.

© 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.