FAQ Qt
FAQ QtConsultez toutes les FAQ
Nombre d'auteurs : 26, nombre de questions : 298, dernière mise à jour : 15 juin 2021
Sommaire→Modules→Qt Core→Fichiers et répertoires→Récupérer des informations- Comment obtenir des informations de fichiers ?
- Comment obtenir les informations des fichiers d'un dossier ?
- Comment récupérer le nom de fichier ?
- Comment distinguer les fichiers des dossiers ?
- Comment vérifier les droits sur un fichier ?
- Comment récupérer l'emplacement d'un fichier ?
- Comment savoir s'il s'agit d'un bundle ? (Mac OS X)
- Comment obtenir la date de dernière modification ?
- Comment récupérer la taille d'un fichier ?
- Comment surveiller la modification d'un fichier ou d'un dossier ?
La classe QFileInfo est réservée à cet usage. Elle est prévue pour pouvoir être utilisée sous toutes les plateformes de la même manière.
Avant de pouvoir voir les informations d'un fichier, vous devez créer un objet QFileInfo. Pour ce faire, il y a trois manières de procéder.
1. Vous utilisez le chemin vers le fichier (QString).
Tous ces paramètres sont équivalents :
- QString ("/home/qt/bin/qmake")
- QString ("/home/./qt/lib/../bin/qmake")
- QString ("./../../home/./qt/lib/../bin/qmake") (si vous vous situez au deuxième niveau d'arborescence dans un point de montage)
QFileInfo qmake (QString ("/home/qt/bin/qmake") );2. Vous réutilisez un QFile.
QFile qmakeFile (QString ("/home/qt/bin/qmake") );
QFileInfo qmake (qmakeFile);3. Vous utilisez le chemin vers le fichier (QDir) et son nom (QString).
QDir qmakeDir ( QString ("/home/qt/bin/qmake") );
QFileInfo qmake (qmakeDir, QString ("qmake") );Ensuite, vous pourrez utiliser les méthodes de QFileInfo pour récupérer les informations qui vous sont nécessaires.
Lien : Comment récupérer le nom de fichier ?
Lien : Comment distinguer les fichiers des dossiers ?
Lien : Comment vérifier les droits sur un fichier ?
Lien : Comment récupérer l'emplacement d'un fichier ?
Lien : Comment savoir s'il s'agit d'un bundle ?
Pour obtenir des informations sur des fichiers, il faut utiliser la classe QFileInfo.
Pour récupérer les informations des fichiers contenus dans un dossier QDir fournit la méthode QDir::entryInfoList(). Cette méthode prend en paramètres des filtres permettant de sélectionner le type de fichier requis.
Grâce aux caching des QFileInfo dans QDir, il est plus efficace d'utiliser cette méthode que de créer manuellement un QFileInfo sur chacun des fichiers.
QDir dir("/developpez/");
foreach(QFileInfo &fileInfo, dir.entryInfoList()) {
fileInfo->isBundle();
}Vous pouvez récupérer tout ou partie du nom de fichier.
QFileInfo file("/tmp/archive.tar.gz");
file.fileName() // == QString ("archive.tar.gz")
file.baseName() // == QString("archive")
file.completeBaseName() // base == QString("archive.tar")
file.suffix() // == QString("gz")
file.completeSuffix() // QString("tar.gz")Qt nous fournit deux fonctions aux noms explicites : isFile() et isDir().
isDir() retournera true si le QFileInfo pointe vers un dossier ou vers un lien symbolique sur un dossier.
isFile() retournera true si le QFileInfo pointe vers un fichier ou vers un lien symbolique sur un fichier.
isSymLink() retournera true si le QFileInfo pointe vers un lien symbolique ou vers un raccourci (sous Windows uniquement).
Sous Windows, quand vous ouvrez un raccourci, c'est le fichier .lnk qui est ouvert, et non le fichier vers lequel il pointe.
QFileInfo file("/tmp/archive.tar.gz");
file->isDir() // == false
file->isFile() // == true
file->isSymLink // == false
QFileInfo libc ("/bin/libstdc++.so");
// En général, ce fichier est un lien symbolique
// vers /bin/libstdc++.so.3
libc->isDir() // == false
libc->isFile() // == true
libc->isSymLink // == true
QFileInfo usr ("/usr");
// Sous les UNIX, un point de montage
// est un dossier comme un autre
usr->isDir() // == true
usr->isFile() // == false
usr->isSymLink // == falseLes trois droits principaux sont la lecture, l'écriture et l'exécution, que ce soit sur Windows (NT) ou sur un des dérivés d'UNIX. Les seules exceptions sont les OS basés sur DOS : MS-DOS, PC-DOS, Windows 1 jusqu'à Millenium (toutes les versions basées sur MS-DOS). Ces OS ne tiennent pas compte des droits.
Il existe une fonction pour récupérer individuellement les droits : isReadable(), isWritable(), isExecutable(), en rapport avec l'utilisateur qui lance votre programme. Il existe aussi la fonction permissions() qui permet de récupérer tous ces droits pour tous, pour un groupe, pour un utilisateur et pour le possesseur.
QFileInfo file ("/etc/hosts");
if ( file.isReadable() )
// Opération de lecture sur fichier
if ( file.isWritable() )
// Opération d'écriture sur le fichier
if ( file.isExecutable() )
// Opération d'exécution sur le fichier
if ( file.permissions() &QFile::ReadUser )
// Opération de lecture sur le fichierQuand vous utilisez un système de fichier NTFS (par défaut sous Windows NT), les droits ne sont pas vérifiés, car cela prend trop de temps. Si vous désirez que Qt les vérifie quand même, insérez cette ligne dans votre code.
extern Q_CORE_EXPORT int qt_ntfs_permission_lookup;Ensuite, pour demander la vérification, il faut incrémenter qt_ntfs_permission_lookup. Pour la désactiver, il suffit de le décrémenter.
qt_ntfs_permission_lookup++; // Activation de la vérification
qt_ntfs_permission_lookup--; // Désactivation de la vérificationVous pouvez récupérer l'emplacement absolu ou relatif de ce fichier. Si le chemin est relatif, vous pouvez le transformer en un chemin absolu.
QFileInfo qmake ("/home/qt/bin/qmake");
QFileInfo qmake2 ("/home/./qt/lib/../bin/qmake");
QFileInfo qmake3 ("./../../home/./qt/lib/../bin/qmake");
QFileInfo qmake4 ("C:/Qt/4.5.2/bin/qmake.exe");
qmake.absoluteFilePath() // == QString("/home/qt/bin/qmake")
qmake2.absoluteFilePath() // == QString("/home/./qt/lib/../bin/qmake")
qmake3.absoluteFilePath() // == QString("/home/./qt/lib/../bin/qmake")
qmake4.absoluteFilePath() == QString("C:/Qt/4.5.2/bin/qmake.exe")
qmake.absoluteDir() // == QDir ("/home/qt/bin")
qmake2.absoluteDir() // == QDir ("/home/./qt/lib/../bin")
qmake3.absoluteDir() // == QDir ("./../../home/./qt/lib/../bin")
qmake4.absoluteDir() == QDir ("C:/Qt/4.5.2/bin")
qmake.absolutePath() // == QString("/home/qt/bin/")
qmake2.absolutePath() // == QString("/home/./qt/lib/../bin/")
qmake3.absolutePath() // == QString("./../../home/./qt/lib/../bin/")
qmake4.absolutePath() == QString("C:/Qt/4.5.2/bin")
qmake.canonicalPath() // == QString("/home/qt/bin/")
qmake2.canonicalPath() // == QString("/home/qt/bin/")
qmake3.canonicalPath() // == QString("/home/qt/bin/")
qmake4.canonicalPath() == QString("C:/Qt/4.5.2/bin")
qmake.canonicalFilePath() // == QString("/home/qt/bin/qmake")
qmake2.canonicalFilePath() // == QString("/home/qt/bin/qmake")
qmake3.canonicalFilePath() // == QString("/home/qt/bin/qmake")
qmake4.canonicalFilePath() == QString("C:/Qt/4.5.2/bin/qmake.exe")
qmake.makeAbsolute(); // == false : déjà absolu
qmake2.makeAbsolute(); // == true
qmake3.makeAbsolute(); // == true
qmake4.makeAbsolute(); // == false : déjà absoluMac OS X rassemble toutes les applications dans ce qui apparaît comme un seul fichier. C'est ce fichier qui est appelé bundle.
La classe QFileInfo propose quelques fonctions spécialisées dans la gestion de ces bundles.
QFileInfo file ("/Applications/Safari.app");
file.isBundle() // == true
file.bundleName() // == QString("Safari")La classe QFileInfo nous propose la méthode lastModified(), qui retourne la date de dernière modification sous forme de QDateTime.
QFileInfo file("/tmp/archive.tar.gz");
QDateTime lastModified = file.lastModified();
qDebug() << "File \"" << file.fileName() << "\" was modified on " ;
qDebug() << lastModified.date().toString("mm/dd/yyyy") << " at ";
qDebug() << lastModified.time().toString("h:m ap");Pour obtenir la taille d'un fichier, nul besoin d'utiliser l'artillerie lourde comme QFile : un objet QFileInfo peut retourner cette information
QFileInfo file ("~/file.ext");
qint64 size;
size = file.size();Mais vous pouvez aussi utiliser QFile dans ce but.
QFile file ("~/file.ext");
qint64 size;
size = file.size();Si vous essayez de déterminer la taille d'un fichier vide sous UNIX (comme /proc), la fonction retournera 0. Le contenu sera généré lors de l'appel à read().
Arrivée avec Qt 4.2, la classe QFileSystemWatcher permet de surveiller les fichiers et les dossiers sur le plan de la modification, avertissant immédiatement en cas de changement avec les signaux directoryChanged(const QString & path) pour les dossiers et fileChanged(const QString & path) pour les fichiers, path définissant dans les deux cas le chemin du fichier/dossier ayant changé.
La surveillance des fichiers et des dossiers ne se fait évidemment pas sur l'intégralité de la machine sur laquelle le programme est exécuté. Pour surveiller un fichier/dossier, il faut appeler la fonction addPath(const QString & path), path correspondant au chemin relatif ou absolu du fichier, ou bien addPaths(const QStringList & paths), paths correspondant à une QStringList de chemins relatifs et/ou absolus.
Comme précisé dans la documentation de QFileSystemWatcher, l'utilisation d'un tel système de surveillance utilise des ressources, ce qui signifie qu'on ne peut pas surveiller une infinité de fichiers et dossiers et qu'il faut donc utiliser cette classe avec modération, sachant que certains systèmes supportent la surveillance d'un maximum de deux cent cinquante-six fichiers/dossiers.
Voici un exemple simple d'utilisation de QFileSystemWatcher pour surveiller deux fichiers :
#include <QApplication>
#include <QObject>
#include <QLabel>
#include <QFileSystemWatcher>
class MyClass : public QLabel
{
Q_OBJECT
public slots:
void changeHappen(const QString &path) {
// path contient le chemin du fichier ayant changé.
setText("Le fichier " + path + " a changé depuis l'extérieur.");
}
};
#include "main.moc"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QString _str("Dans cette zone va s'afficher "
"le chemin du fichier ayant changé en dernier.");
// Instance de la classe contenant le slot à appeler :
MyClass _instance;
_instance.show();
_instance.setWordWrap(true);
_instance.resize(300, 100);
_instance.setContentsMargins(10, 10, 10, 10);
_instance.setText(_str);
// Création du watcher :
QFileSystemWatcher _watcher;
// Ajout des fichiers à surveiller (on aurait pu utiliser une QStringList) :
_watcher.addPath("fichier_a_surveiller.txt");
_watcher.addPath("autre_fichier.txt");
// Connexion du watcher au slot de la classe MyClass :
QObject::connect(&_watcher, SIGNAL(fileChanged(const QString &)),
&_instance, SLOT(changeHappen(const QString &)));
return a.exec();
}