Sur cette page

QFileDevice Class

La classe QFileDevice fournit une interface pour lire et écrire dans des fichiers ouverts. Plus d'informations...

En-tête : #include <QFileDevice>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core
Hérite : QIODevice
Héritée 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 pour les périphériques d'E/S qui peuvent lire et écrire des fichiers texte et binaires et des ressources. QFile offre la fonctionnalité principale, QFileDevice sert de classe de base pour partager la fonctionnalité avec d'autres périphériques de fichiers tels que QSaveFile, en fournissant toutes les opérations qui peuvent être effectuées sur des fichiers qui ont été ouverts par QFile ou QSaveFile.

Voir également QFile et QSaveFile.

Documentation sur les types de membres

enum QFileDevice::FileError

Cette liste décrit les erreurs qui peuvent être renvoyées par la fonction error().

ConstanteValeurDescription de l'erreur
QFileDevice::NoError0Aucune erreur n'est survenue.
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, manque de mémoire, etc.)
QFileDevice::OpenError5Le fichier n'a pas pu être ouvert.
QFileDevice::AbortError6L'opération a été interrompue.
QFileDevice::TimeOutError7Un dépassement de délai s'est produit.
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::PositionError11La position dans le fichier n'a pas pu être modifiée.
QFileDevice::ResizeError12Le fichier n'a pas pu être redimensionné.
QFileDevice::PermissionsError13Le fichier n'a pas pu être accédé.
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 ne s'appliquent qu'aux fichiers et non à un périphérique générique QIODevice.

ConstanteValeurDescription de la constante
QFileDevice::AutoCloseHandle0x0001La poignée de fichier passée à open() doit être fermée par close(), le comportement par défaut est que close ne fait que vider le fichier et que l'application est responsable de la fermeture de la poignée de fichier. Lors de l'ouverture d'un fichier par son nom, ce drapeau est ignoré car Qt possède toujours la poignée de fichier et doit la fermer.
QFileDevice::DontCloseHandle0Si elle n'est pas explicitement fermée, la poignée de fichier sous-jacente reste ouverte lorsque l'objet QFile est détruit.

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

enum QFileDevice::FileTime

Cette liste 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 pris 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 liste décrit les options spéciales qui peuvent être utilisées par la fonction map().

ConstanteValeurDescription de la fonction
QFileDevice::NoOptions0Aucune option.
QFileDevice::MapPrivateOption0x0001La mémoire mappée sera privée, de sorte que toute modification ne sera pas 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 à travers la mémoire mappée. Cette valeur a été introduite dans Qt 5.4.

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

enum QFileDevice::Permission
flags QFileDevice::Permissions

Cette énumération est utilisée par la fonction permission() pour indiquer les autorisations et la propriété d'un fichier. Les valeurs peuvent être combinées par OU pour tester plusieurs valeurs de permissions et de propriété.

ConstanteValeurDescription du fichier
QFileDevice::ReadOwner0x4000Le fichier peut être lu par le propriétaire du fichier.
QFileDevice::WriteOwner0x2000Le fichier est accessible en écriture par le propriétaire du fichier.
QFileDevice::ExeOwner0x1000Le fichier est exécutable par le propriétaire du fichier.
QFileDevice::ReadUser0x0400Le fichier est lisible par l'utilisateur.
QFileDevice::WriteUser0x0200Le fichier peut être écrit par l'utilisateur.
QFileDevice::ExeUser0x0100Le fichier est exécutable par l'utilisateur.
QFileDevice::ReadGroup0x0040Le fichier est lisible par le groupe.
QFileDevice::WriteGroup0x0020Le fichier peut être écrit par le groupe.
QFileDevice::ExeGroup0x0010Le fichier est exécutable par le groupe.
QFileDevice::ReadOther0x0004Le fichier est lisible par d'autres.
QFileDevice::WriteOther0x0002Le fichier est inscriptible par d'autres.
QFileDevice::ExeOther0x0001Le fichier est exécutable par d'autres.

Attention : En raison des différences entre les plateformes supportées par Qt, la sémantique de ReadUser, WriteUser et ExeUser dépend de la plateforme : Sous Unix, les droits du propriétaire du fichier sont renvoyés et sous Windows, les droits de l'utilisateur actuel sont renvoyés. Ce comportement pourrait changer dans une future version de Qt.

Note : Sur les systèmes de fichiers NTFS, la vérification de la propriété et des permissions est désactivée par défaut pour des raisons de performance. Pour l'activer, ajoutez la ligne suivante :

extern Q_CORE_EXPORT int qt_ntfs_permission_lookup;

La vérification des permissions est ensuite activée et désactivée en incrémentant et décrémentant 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 prudent d'incrémenter ou de décrémenter qt_ntfs_permission_lookup qu'avant le démarrage de tout autre thread que le thread principal ou après la fin de tout autre thread que le thread principal.

Note : À 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 contrôles de permission est d'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'étatqEnableNtfsPermissionChecks();       // turn checking on
qDisableNtfsPermissionChecks();      // turn it off again

Le type Permissions est un typedef pour QFlags<Permission>. Il stocke une combinaison OU de valeurs de 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 ordinaires sous Unix (par exemple ceux qui se trouvent dans /proc), cette fonction renvoie true, car le système de fichiers signale que la taille d'un tel fichier est de 0. Par conséquent, vous ne devez pas dépendre de atEnd() lorsque vous lisez des 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 : QIODevice::close().

Appelle QFileDevice::flush() et ferme le fichier. Les erreurs provenant de flush sont ignorées.

Voir aussi QIODevice::close().

QFileDevice::FileError QFileDevice::error() const

Renvoie l'état d'erreur du fichier.

L'état du périphérique d'E/S renvoie un code d'erreur. Par exemple, si open() renvoie false, ou si une opération de lecture/écriture renvoie -1, cette fonction peut être appelée pour connaître 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 de caractères nulle.

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

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

Voir aussi setFileTime(), FileTime, et QDateTime::isValid().

bool QFileDevice::flush()

Vide toutes les données mises en mémoire tampon dans le fichier. Renvoie true en cas de succès, sinon false.

int QFileDevice::handle() const

Renvoie l'identifiant du fichier.

Il s'agit d'un petit nombre entier positif, utilisable avec les 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), le handle peut également être utilisé avec QSocketNotifier.

Si le fichier n'est pas ouvert ou s'il y a une erreur, handle() renvoie -1.

Voir aussi 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 supportent l'accès aléatoire, mais certains fichiers spéciaux ne le supportent pas.

Voir également QIODevice::isSequential().

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

Mappage de size octets du fichier dans la mémoire à partir de offset. Un fichier doit être ouvert pour qu'un mappage réussisse, mais il n'est pas nécessaire que le fichier reste ouvert une fois que la mémoire a été mappée. Lorsque QFile est détruit ou qu'un nouveau fichier est ouvert avec cet objet, toutes les cartes qui n'ont pas été démappées le seront automatiquement.

La cartographie aura le même mode d'ouverture que le fichier (lecture et/ou écriture), sauf si l'on utilise MapPrivateOption, auquel cas il est toujours possible d'écrire dans la mémoire cartographiée.

Toutes les options de mappage peuvent être transmises par l'intermédiaire de flags.

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

Voir aussi unmap().

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

Renvoie la combinaison complète OR-ed together de QFile::Permission pour le 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émente : 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 plus grand que le fichier actuel, les nouveaux octets seront mis à 0 ; si sz est plus petit, le fichier est simplement tronqué.

Attention : 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 actuelle à pos, en renvoyant true en cas de succès, ou false en cas d'erreur. Pour les périphériques séquentiels, le comportement par défaut est de ne rien faire et de renvoyer false.

Recherche au-delà de la fin d'un fichier : Si la position est au-delà de la fin d'un fichier, seek() n'étend pas immédiatement le fichier. Si une écriture est effectuée à cette position, le fichier sera étendu. Le contenu du fichier entre la fin du fichier précédent et les données nouvellement écrites n'est pas défini et varie selon les plates-formes et les systèmes de fichiers.

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

Définit la durée du fichier spécifiée par fileTime à newDate, en renvoyant true en cas de succès, sinon en renvoyant false.

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

Voir aussi fileTime() et FileTime.

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

Définit les permissions pour le fichier à l'adresse permissions spécifiée. Retourne true en cas de succès, ou false si les permissions ne peuvent pas être modifiées.

Attention : Cette fonction ne manipule pas les 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 ordinaires sous Unix (par exemple ceux qui se trouvent dans /proc), cette fonction renvoie 0 ; le contenu d'un tel fichier est généré à la demande en réponse à l'appel de read().

bool QFileDevice::unmap(uchar *address)

Démappage de la mémoire address.

Renvoie true si la désimplantation réussit, false dans le cas contraire.

Voir aussi map().

void QFileDevice::unsetError()

Définit l'erreur du fichier à 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 de la macro

[since 6.8] QT_USE_NODISCARD_FILE_OPEN

[since 6.8] QT_NO_USE_NODISCARD_FILE_OPEN

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

Pour cette raison, à partir de Qt 6.8, certaines surcharges de open() ont été marquées avec l'attribut [[nodiscard]]. Comme ce changement peut soulever des avertissements dans les bases de code existantes, le code utilisateur peut accepter ou refuser l'application de l'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 macro n'est définie, la valeur par défaut jusqu'à Qt 6.9 inclus est de ne pas avoir l'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.