QFile Class
La classe QFile fournit une interface pour la lecture et l'écriture de fichiers. Plus d'informations...
| En-tête : | #include <QFile> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core)target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
| Hérite : | QFileDevice |
| Hérité par : |
- Liste de tous les membres, y compris les membres hérités
- QFile fait partie de Entrées/Sorties et Réseaux.
Note : Toutes les fonctions de cette classe sont réentrantes.
Fonctions publiques
| 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) |
(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 |
Fonctions publiques réimplémentées
| 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 |
Membres publics statiques
| bool | copy(const QString &fileName, const QString &newName) |
| 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) |
Description détaillée
QFile est un périphérique d'E/S permettant de lire et d'écrire des fichiers et des ressources textuels et binaires. Un QFile peut être utilisé seul ou, plus commodément, avec un QTextStream ou un QDataStream.
Le nom du fichier est généralement transmis dans le constructeur, mais il peut être défini à tout moment à l'aide de setFileName(). QFile s'attend à ce que le séparateur de fichier soit '/' quel que soit le système d'exploitation. L'utilisation d'autres séparateurs (par exemple, '\') n'est pas prise en charge.
Vous pouvez vérifier l'existence d'un fichier en utilisant exists(), et supprimer un fichier en utilisant remove(). (Des opérations plus avancées liées au système de fichiers sont fournies par QFileInfo et QDir).
Le fichier est ouvert avec open(), fermé avec close() et effacé avec flush(). Les données sont généralement lues et écrites à l'aide de QDataStream ou QTextStream, mais vous pouvez également appeler les fonctions héritées de QIODevice: read(), readLine(), readAll(), write(). QFile hérite également des fonctions getChar(), putChar() et ungetChar(), qui travaillent un caractère à la fois.
La taille du fichier est renvoyée par size(). Vous pouvez obtenir la position actuelle du fichier en utilisant pos(), ou vous déplacer vers une nouvelle position du fichier en utilisant seek(). Si vous avez atteint la fin du fichier, atEnd() renvoie true.
Lecture directe de fichiers
L'exemple suivant lit un fichier texte ligne par ligne :
QFile file("in.txt"); if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) return; while (!file.atEnd()) { QByteArray line = file.readLine(); process_line(line); }
Le drapeau Text transmis à open() indique à Qt XML de convertir les terminaisons de ligne de style Windows ("\r\n ") en terminaisons de style C++ ("\n"). Par défaut, QFile suppose qu'il s'agit d'un fichier binaire, c'est-à-dire qu'il n'effectue aucune conversion sur les octets stockés dans le fichier.
Utilisation de flux pour lire des fichiers
L'exemple suivant utilise QTextStream pour lire un fichier texte ligne par ligne :
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 charge de convertir les données de 8 bits stockées sur le disque en un code Unicode de 16 bits QString. Par défaut, il suppose que le fichier est encodé en UTF-8. Ceci peut être modifié en utilisant QTextStream::setEncoding().
Pour écrire du texte, nous pouvons utiliser l'opérateur<<(), qui est surchargé pour prendre un QTextStream à gauche et divers types de données (y compris QString) à droite :
QFile file("out.txt"); if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) return; QTextStream out(&file); out << "The magic number is: " << 49 << "\n";
QDataStream est similaire, en ce sens que vous pouvez utiliser operator<<() pour écrire des données et operator>>() pour les relire. Voir la documentation de la classe pour plus de détails.
Signaux
Contrairement à d'autres implémentations de QIODevice, telles que QTcpSocket, QFile n'émet pas les signaux aboutToClose(), bytesWritten() ou readyRead(). Ce détail d'implémentation signifie que QFile n'est pas adapté à la lecture et à l'écriture de certains types de fichiers, tels que les fichiers de périphériques sur les plates-formes Unix.
Problèmes spécifiques aux plates-formes
Les API Qt liées aux E/S utilisent des chaînes de caractères QStrings basées sur l'UTF-16 pour représenter les chemins d'accès aux fichiers. Les API C++ standard (<cstdio> ou <iostream>) ou les API spécifiques à une plate-forme ont cependant souvent besoin d'un chemin codé sur 8 bits. Vous pouvez utiliser encodeName() et decodeName() pour convertir les deux représentations.
Sous Unix, il existe des fichiers système spéciaux (par exemple dans /proc) pour lesquels size() renverra toujours 0. Il se peut néanmoins que vous puissiez lire d'autres données à partir d'un tel fichier ; les données sont générées en réponse directe à votre appel à read(). Dans ce cas, cependant, vous ne pouvez pas utiliser atEnd() pour déterminer s'il y a plus de données à lire (puisque atEnd() renverra vrai pour un fichier qui prétend avoir une taille de 0). Au lieu de cela, vous devez soit appeler readAll(), soit appeler read() ou readLine() à plusieurs reprises jusqu'à ce qu'il n'y ait plus de données à lire. L'exemple suivant utilise QTextStream pour lire /proc/modules ligne par ligne :
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(); }
Les autorisations de fichiers sont gérées différemment sur les systèmes de type Unix et Windows. Sur les systèmes de type Unix, il est impossible de créer des fichiers dans un répertoire qui n'est pas writable. Ce n'est pas toujours le cas sous Windows, où, par exemple, le répertoire "Mes documents" n'est généralement pas accessible en écriture, mais il est toujours possible d'y créer des fichiers.
La compréhension par Qt XML des permissions de fichiers est limitée, ce qui affecte particulièrement la fonction QFile::setPermissions(). Sous Windows, Qt ne met en place que l'ancien drapeau de lecture seule, et ce uniquement si aucun des drapeaux d'écriture* n'est transmis. Qt ne manipule pas les listes de contrôle d'accès (ACL), ce qui rend cette fonction pratiquement inutile pour les volumes NTFS. Elle peut néanmoins être utile pour les clés USB qui utilisent des systèmes de fichiers VFAT. Les ACL POSIX ne sont pas non plus manipulées.
Sur Android, certaines limitations s'appliquent lorsqu'il s'agit de traiter des URI de contenu:
- Des autorisations d'accès peuvent être nécessaires en demandant à l'utilisateur d'utiliser le site QFileDialog qui met en œuvre le sélecteur de fichiers natif d'Android.
- Essayez de suivre les lignes directrices relatives au stockage ciblé, en utilisant par exemple des répertoires spécifiques à l'application plutôt que des répertoires externes publics. Pour plus d'informations, consultez également les meilleures pratiques en matière de stockage.
- En raison de la conception des API de Qt Designer (par exemple QFile), il n'est pas possible d'intégrer pleinement ces dernières aux API du MediaStore d'Android.
Voir aussi QTextStream, QDataStream, QFileInfo, QDir, et Le système de ressources Qt.
Documentation des fonctions membres
QFile::QFile()
Construit un objet QFile.
[explicit] QFile::QFile(QObject *parent)
Construit un nouvel objet fichier avec l'adresse parent.
[explicit] QFile::QFile(const QString &name)
Construit un nouvel objet file pour représenter le fichier avec l'adresse name.
Note : Dans les versions jusqu'à Qt 6.8 inclus, ce constructeur est implicite, pour des raisons de compatibilité ascendante. À partir de Qt 6.9, ce constructeur est inconditionnellement explicit. Les utilisateurs peuvent forcer ce constructeur à être explicit même dans les versions antérieures de Qt en définissant la macro QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH avant d'inclure tout en-tête Qt.
[explicit, since 6.0] QFile::QFile(const std::filesystem::path &name)
Construit un nouvel objet file pour représenter le fichier avec l'adresse name.
Note : Dans les versions jusqu'à Qt 6.8 inclus, ce constructeur est implicite, pour des raisons de compatibilité ascendante. À partir de Qt 6.9, ce constructeur est inconditionnellement explicit. Les utilisateurs peuvent forcer ce constructeur à être explicit même dans les versions antérieures de Qt en définissant la macro QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH avant d'inclure tout en-tête Qt.
Cette fonction a été introduite dans Qt 6.0.
QFile::QFile(const QString &name, QObject *parent)
Construit un nouvel objet fichier avec l'adresse parent donnée pour représenter le fichier avec l'adresse name spécifiée.
[since 6.0] QFile::QFile(const std::filesystem::path &name, QObject *parent)
Construit un nouvel objet fichier avec l'adresse parent donnée pour représenter le fichier avec l'adresse name spécifiée.
Cette fonction a été introduite dans Qt 6.0.
[virtual noexcept] QFile::~QFile()
Détruit l'objet fichier, en le fermant si nécessaire.
bool QFile::copy(const QString &newName)
Copie le fichier nommé fileName() vers newName.
Ce fichier est fermé avant d'être copié.
Si le fichier copié est un lien symbolique (symlink), c'est le fichier auquel il fait référence qui est copié, et non le lien lui-même. À l'exception des autorisations, qui sont copiées, aucune autre métadonnée de fichier n'est copiée.
Renvoie true en cas de succès, sinon false.
Notez que si un fichier portant le nom newName existe déjà, copy() renvoie false. Cela signifie que QFile ne l'écrasera pas.
Remarque : sur Android, cette opération n'est pas encore prise en charge pour les URI de schéma content.
Voir également setFileName().
[since 6.0] bool QFile::copy(const std::filesystem::path &newName)
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.0.
[static] bool QFile::copy(const QString &fileName, const QString &newName)
Copie le fichier nommé fileName dans newName.
Si le fichier copié est un lien symbolique (symlink), c'est le fichier auquel il fait référence qui est copié, et non le lien lui-même. À l'exception des autorisations, qui sont copiées, aucune autre métadonnée de fichier n'est copiée.
Renvoie true en cas de succès, sinon false.
Notez que si un fichier portant le nom newName existe déjà, copy() renvoie false. Cela signifie que QFile ne l'écrasera pas.
Remarque : sur Android, cette opération n'est pas encore prise en charge pour les URI de schéma content.
Il s'agit d'une fonction surchargée.
Voir aussi rename().
[static] QString QFile::decodeName(const QByteArray &localFileName)
Il s'agit de l'inverse de QFile::encodeName() qui utilise localFileName.
Voir également encodeName().
[static] QString QFile::decodeName(const char *localFileName)
Renvoie la version Unicode de l'adresse localFileName donnée. Voir encodeName() pour plus de détails.
Il s'agit d'une fonction surchargée.
[static] QByteArray QFile::encodeName(const QString &fileName)
Convertit fileName en un encodage 8 bits que vous pouvez utiliser dans les API natives. Sous Windows, l'encodage est celui de la page de code Windows active (ANSI). Sur les autres plateformes, il s'agit d'UTF-8, pour macOS sous forme décomposée (NFD).
Voir aussi decodeName().
[static] bool QFile::exists(const QString &fileName)
Renvoie true si le fichier spécifié par fileName existe ; sinon, renvoie false.
Remarque : si fileName est un lien symbolique qui pointe vers un fichier inexistant, le système renvoie false.
bool QFile::exists() const
Renvoie true si le fichier spécifié par fileName() existe ; sinon, renvoie false.
Il s'agit d'une fonction surchargée.
Voir aussi fileName() et setFileName().
[override virtual] QString QFile::fileName() const
Réimplémente : QFileDevice::fileName() const.
Renvoie le nom du fichier tel qu'il a été défini par setFileName(), rename() ou par les constructeurs de QFile.
Voir aussi setFileName(), rename() et QFileInfo::fileName().
[since 6.0] std::filesystem::path QFile::filesystemFileName() const
Renvoie fileName() sous la forme std::filesystem::path.
Cette fonction a été introduite dans Qt 6.0.
[since 6.3] std::filesystem::path QFile::filesystemSymLinkTarget() const
Retourne symLinkTarget() comme std::filesystem::path.
Cette fonction a été introduite dans Qt 6.3.
[static, since 6.3] std::filesystem::path QFile::filesystemSymLinkTarget(const std::filesystem::path &fileName)
Renvoie symLinkTarget() en tant que std::filesystem::path de fileName.
Cette fonction a été introduite dans Qt 6.3.
bool QFile::link(const QString &linkName)
Crée un lien nommé linkName qui pointe vers le fichier actuellement spécifié par fileName(). La nature d'un lien dépend du système de fichiers sous-jacent (qu'il s'agisse d'un raccourci sous Windows ou d'un lien symbolique sous Unix). Renvoie true en cas de succès, sinon false.
Cette fonction n'écrase pas une entité déjà existante dans le système de fichiers ; dans ce cas, link() renverra false et error() renverra RenameError.
Remarque : pour créer un lien valide sous Windows, linkName doit avoir une extension de fichier .lnk.
Voir également setFileName().
[since 6.0] bool QFile::link(const std::filesystem::path &newName)
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.0.
[static] bool QFile::link(const QString &fileName, const QString &linkName)
Crée un lien nommé linkName qui pointe vers le fichier fileName. La nature d'un lien dépend du système de fichiers sous-jacent (qu'il s'agisse d'un raccourci sous Windows ou d'un lien symbolique sous Unix). Renvoie true en cas de succès, sinon false.
Il s'agit d'une fonction surchargée.
Voir aussi link().
bool QFile::moveToTrash()
Déplace le fichier spécifié par fileName() vers la corbeille. Elle renvoie true en cas de succès et définit fileName() comme chemin d'accès au fichier dans la corbeille ; sinon, elle renvoie false.
Le temps d'exécution de cette fonction est indépendant de la taille du fichier à mettre à la corbeille. Si cette fonction est appelée dans un répertoire, elle peut être proportionnelle au nombre de fichiers mis à la corbeille. Si le fichier actuel fileName() pointe vers un lien symbolique, cette fonction déplacera le lien vers la corbeille, en le brisant éventuellement, et non la cible du lien.
Cette fonction utilise les API Windows et macOS pour effectuer la mise à la corbeille sur ces deux systèmes d'exploitation. Ailleurs (systèmes Unix), cette fonction implémente la spécification FreeDesktop.org Trash version 1.0.
Note : Lors de l'utilisation de l'implémentation de la Corbeille de FreeDesktop.org, cette fonction échouera si elle n'est pas en mesure de déplacer les fichiers vers l'emplacement de la corbeille par le biais de renommages de fichiers et de liens en dur. Cette condition survient si le fichier mis à la corbeille réside sur un volume (point de montage) sur lequel l'utilisateur actuel n'a pas la permission de créer le répertoire .Trash, ou avec des types de systèmes de fichiers ou des configurations inhabituelles (comme des sous-volumes qui ne sont pas eux-mêmes des points de montage).
Remarque : sur les systèmes où l'API du système ne signale pas l'emplacement du fichier dans la corbeille, fileName() prendra la valeur null une fois que le fichier aura été déplacé. Sur les systèmes qui n'ont pas de corbeille, cette fonction renvoie toujours false (voir supportsMoveToTrash()).
Voir aussi supportsMoveToTrash(), remove() et QDir::remove().
[static] bool QFile::moveToTrash(const QString &fileName, QString *pathInTrash = nullptr)
Déplace le fichier spécifié par fileName dans la corbeille. Renvoie true en cas de succès, et attribue à pathInTrash (s'il est fourni) le chemin d'accès au fichier dans la corbeille ; sinon, renvoie false.
Le temps d'exécution de cette fonction est indépendant de la taille du fichier à mettre à la corbeille. Si cette fonction est appelée dans un répertoire, elle peut être proportionnelle au nombre de fichiers mis à la corbeille. Si le fichier actuel fileName() pointe vers un lien symbolique, cette fonction déplacera le lien vers la corbeille, en le brisant éventuellement, et non la cible du lien.
Cette fonction utilise les API Windows et macOS pour effectuer la mise à la corbeille sur ces deux systèmes d'exploitation. Ailleurs (systèmes Unix), cette fonction implémente la spécification FreeDesktop.org Trash version 1.0.
Note : Lors de l'utilisation de l'implémentation de la Corbeille de FreeDesktop.org, cette fonction échouera si elle n'est pas en mesure de déplacer les fichiers vers l'emplacement de la corbeille par le biais de renommages de fichiers et de liens en dur. Cette condition survient si le fichier mis à la corbeille réside sur un volume (point de montage) sur lequel l'utilisateur actuel n'a pas la permission de créer le répertoire .Trash, ou avec des types de systèmes de fichiers ou des configurations inhabituelles (comme des sous-volumes qui ne sont pas eux-mêmes des points de montage).
Remarque : sur les systèmes où l'API du système ne signale pas le chemin du fichier dans la corbeille, pathInTrash sera défini comme une chaîne nulle une fois que le fichier aura été déplacé. Sur les systèmes qui n'ont pas de corbeille, cette fonction renvoie toujours false.
Il s'agit d'une fonction surchargée.
[override virtual] bool QFile::open(QIODeviceBase::OpenMode mode)
Réimplémente : QIODevice::open(QIODeviceBase::OpenMode mode).
Ouvre le fichier en utilisant les drapeaux mode et renvoie true en cas de succès ; sinon, renvoie false.
Les drapeaux de mode doivent inclure QIODeviceBase::ReadOnly, WriteOnly, ou ReadWrite. Il peut également y avoir des drapeaux supplémentaires, tels que Text et Unbuffered.
Remarque : en mode WriteOnly ou ReadWrite, si le fichier concerné n'existe pas encore, cette fonction tentera de créer un nouveau fichier avant de l'ouvrir. Le fichier sera créé avec le mode 0666 masqué par l'umask sur les systèmes POSIX, et avec les permissions héritées du répertoire parent sur Windows. Sur Android, il faut avoir les droits d'accès au parent du nom de fichier, sinon il ne sera pas possible de créer ce fichier inexistant.
Voir aussi QT_USE_NODISCARD_FILE_OPEN et setFileName().
[since 6.3] bool QFile::open(QIODeviceBase::OpenMode mode, QFileDevice::Permissions permissions)
Si le fichier n'existe pas et que mode implique de le créer, il est créé avec la valeur spécifiée permissions.
Sur les systèmes POSIX, les autorisations réelles sont influencées par la valeur de umask.
Sous Windows, les autorisations sont émulées à l'aide d'ACL. Ces listes peuvent être dans un ordre non canonique lorsqu'un groupe se voit accorder moins d'autorisations que d'autres. Les fichiers et les répertoires présentant de telles autorisations génèrent des avertissements lorsque l'onglet Sécurité de la boîte de dialogue Propriétés est ouvert. Le fait d'accorder au groupe toutes les autorisations accordées aux autres permet d'éviter ces avertissements.
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.3.
Voir aussi QIODevice::OpenMode, setFileName(), et QT_USE_NODISCARD_FILE_OPEN.
bool QFile::open(FILE *fh, QIODeviceBase::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle)
Ouvre le fichier existant fh dans le répertoire mode. handleFlags peut être utilisé pour spécifier des options supplémentaires. Renvoie true en cas de succès, sinon false.
Exemple :
#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(); }
Lorsqu'un QFile est ouvert à l'aide de cette fonction, le comportement de close() est contrôlé par l'indicateur AutoCloseHandle. Si AutoCloseHandle est spécifié et que cette fonction réussit, l'appel à close() ferme la poignée adoptée. Dans le cas contraire, close() ne ferme pas le fichier, mais le vide.
Attention :
- Si fh ne fait pas référence à un fichier normal, par exemple s'il s'agit de
stdin,stdoutoustderr, il se peut que vous ne puissiez pas utiliser seek(). size() renvoie0dans ces cas. Voir QIODevice::isSequential() pour plus d'informations. - Comme cette fonction ouvre le fichier sans en spécifier le nom, vous ne pouvez pas utiliser cette QFile avec une QFileInfo.
Note pour la plate-forme Windows
fh doit être ouvert en mode binaire (c'est-à-dire que la chaîne de mode doit contenir "b", comme dans "rb" ou "wb") lors de l'accès à des fichiers et à d'autres périphériques à accès aléatoire. Qt traduira les caractères de fin de ligne si vous passez QIODevice::Text à mode. Les périphériques séquentiels, tels que stdin et stdout, ne sont pas concernés par cette limitation.
Vous devez activer la prise en charge des applications de console afin d'utiliser les flux stdin, stdout et stderr sur la console. Pour ce faire, ajoutez la déclaration suivante au fichier de projet de votre application :
CONFIG += console
Ceci est une fonction surchargée.
Voir aussi close() et QT_USE_NODISCARD_FILE_OPEN.
bool QFile::open(int fd, QIODeviceBase::OpenMode mode, QFileDevice::FileHandleFlags handleFlags = DontCloseHandle)
Ouvre le descripteur de fichier existant fd dans le répertoire mode. handleFlags peut être utilisé pour spécifier des options supplémentaires. Renvoie true en cas de succès, sinon false.
Lorsqu'un QFile est ouvert à l'aide de cette fonction, le comportement de close() est contrôlé par l'indicateur AutoCloseHandle. Si AutoCloseHandle est spécifié et que cette fonction réussit, l'appel à close() ferme la poignée adoptée. Dans le cas contraire, close() ne ferme pas le fichier, mais le vide.
Attention : Si fd n'est pas un fichier normal, par exemple 0 (stdin), 1 (stdout) ou 2 (stderr), il se peut que vous ne puissiez pas utiliser seek(). Dans ce cas, size() renvoie 0. Voir QIODevice::isSequential() pour plus d'informations.
Attention : Étant donné que cette fonction ouvre le fichier sans en spécifier le nom, vous ne pouvez pas utiliser cette fonction QFile avec un fichier QFileInfo.
Il s'agit d'une fonction surchargée.
Voir aussi close() et QT_USE_NODISCARD_FILE_OPEN.
[override virtual] QFileDevice::Permissions QFile::permissions() const
Réimplémente : QFileDevice::permissions() const.
Voir également setPermissions().
[static] QFileDevice::Permissions QFile::permissions(const QString &fileName)
Renvoie la combinaison complète OR-ed together de QFile::Permission pour fileName.
Il s'agit d'une fonction surchargée.
[static, since 6.0] QFileDevice::Permissions QFile::permissions(const std::filesystem::path &filename)
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.0.
bool QFile::remove()
Supprime le fichier spécifié par fileName().
Renvoie true si le fichier a été supprimé avec succès ; sinon, renvoie false.
Le fichier est fermé avant d'être supprimé, s'il était ouvert.
Voir aussi setFileName().
[static] bool QFile::remove(const QString &fileName)
Supprime le fichier spécifié par l'adresse fileName.
Renvoie true si le fichier a été supprimé avec succès ; sinon, renvoie false.
Il s'agit d'une fonction surchargée.
Voir aussi remove().
bool QFile::rename(const QString &newName)
Renomme le fichier actuellement spécifié par fileName() en newName. Renvoie true en cas de succès, sinon false.
Si un fichier portant le nom newName existe déjà, rename() renvoie false (c'est-à-dire que QFile ne l'écrasera pas).
Le fichier est fermé avant d'être renommé.
Si l'opération de renommage échoue, Qt XML tentera de copier le contenu de ce fichier sur newName, puis de supprimer ce fichier, en ne conservant que newName. Si cette opération de copie échoue ou si ce fichier ne peut pas être supprimé, le fichier de destination newName est supprimé pour restaurer l'ancien état.
Voir aussi setFileName().
[since 6.0] bool QFile::rename(const std::filesystem::path &newName)
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.0.
[static] bool QFile::rename(const QString &oldName, const QString &newName)
Renomme le fichier oldName en newName. Renvoie true en cas de succès, sinon false.
Si un fichier portant le nom newName existe déjà, rename() renvoie false (c'est-à-dire que QFile ne l'écrasera pas).
Il s'agit d'une fonction surchargée.
Voir aussi rename().
[override virtual] bool QFile::resize(qint64 sz)
Réimplémente : QFileDevice::resize(qint64 sz).
[static] bool QFile::resize(const QString &fileName, qint64 sz)
Définit fileName à la taille (en octets) de sz. Retourne true si le redimensionnement réussit, false dans le cas contraire. Si sz est plus grand que fileName, 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.
Il s'agit d'une fonction surchargée.
Voir aussi resize().
void QFile::setFileName(const QString &name)
Définit l'adresse name du fichier. Le nom peut ne pas avoir de chemin d'accès, avoir un chemin d'accès relatif ou un chemin d'accès absolu.
N'appelez pas cette fonction si le fichier a déjà été ouvert.
Si le nom du fichier n'a pas de chemin d'accès ou un chemin d'accès relatif, le chemin d'accès utilisé sera le chemin d'accès au répertoire courant de l'application au moment de l'appel à open( ).
Exemple :
QFile file; QDir::setCurrent("/tmp"); file.setFileName("readme.txt"); QDir::setCurrent("/home"); file.open(QIODevice::ReadOnly); // opens "/home/readme.txt" under Unix
Notez que le séparateur de répertoire "/" fonctionne pour tous les systèmes d'exploitation pris en charge par Qt.
Voir aussi fileName(), QFileInfo, et QDir.
[since 6.0] void QFile::setFileName(const std::filesystem::path &name)
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.0.
[override virtual] bool QFile::setPermissions(QFileDevice::Permissions permissions)
Réimplémente : 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() et setFileName().
[static] bool QFile::setPermissions(const QString &fileName, QFileDevice::Permissions permissions)
Définit les permissions pour le fichier fileName à permissions.
Il s'agit d'une fonction surchargée.
[static, since 6.0] bool QFile::setPermissions(const std::filesystem::path &filename, QFileDevice::Permissions permissionSpec)
Il s'agit d'une fonction surchargée.
Cette fonction a été introduite dans Qt 6.0.
[override virtual] qint64 QFile::size() const
Réimplémente : QFileDevice::size() const.
[static, since 6.9] bool QFile::supportsMoveToTrash()
Renvoie true si Qt XML supporte le déplacement de fichiers vers une corbeille dans le système d'exploitation actuel en utilisant la fonction moveToTrash(), false sinon. Notez que cette fonction renvoyant true n'implique pas que moveToTrash() réussira. En particulier, cette fonction ne vérifie pas si l'utilisateur a désactivé la fonctionnalité dans ses paramètres.
Cette fonction a été introduite dans Qt 6.9.
Voir aussi moveToTrash().
[static] QString QFile::symLinkTarget(const QString &fileName)
Renvoie le chemin absolu du fichier ou du répertoire auquel se réfère le lien symbolique (ou le raccourci sous Windows) spécifié par fileName, ou renvoie une chaîne vide si fileName ne correspond pas à un lien symbolique.
Ce nom ne peut pas représenter un fichier existant ; il s'agit uniquement d'une chaîne de caractères. QFile::exists() renvoie true si le lien symbolique pointe vers un fichier existant.
QString QFile::symLinkTarget() const
Renvoie le chemin absolu du fichier ou du répertoire vers lequel pointe un lien symbolique (ou un raccourci sous Windows), ou une chaîne vide si l'objet n'est pas un lien symbolique.
Ce nom ne peut pas représenter un fichier existant ; il s'agit uniquement d'une chaîne de caractères. QFile::exists() renvoie true si le lien symbolique pointe vers un fichier existant.
Il s'agit d'une fonction surchargée.
Voir aussi fileName() et 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.