FAQ Qt FAQ Qt Creator FAQ PyQt & PySide

FAQ QtConsultez toutes les FAQ

Nombre d'auteurs : 25, nombre de questions : 299, dernière mise à jour : 15 octobre 2016 

 
OuvrirSommaireModulesQtCoreFichiers et répertoiresRécupérer des informations

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)
 
Sélectionnez
QFileInfo qmake (QString ("/home/qt/bin/qmake") );

2. Vous réutilisez un QFile.

 
Sélectionnez
QFile qmakeFile (QString ("/home/qt/bin/qmake") );
QFileInfo qmake (qmakeFile);

3. Vous utilisez le chemin vers le fichier (QDir) et son nom (QString).

 
Sélectionnez
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.

Créé le 30 octobre 2009  par Thibaut Cuvelier

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.

 
Sélectionnez
QDir dir("/developpez/");
foreach(QFileInfo &fileInfo, dir.entryInfoList()) {
  fileInfo->isBundle();
}
Créé le 30 octobre 2009  par Benjamin Poulain

Lien : Comment obtenir des informations de fichiers ?

Vous pouvez récupérer tout ou partie du nom de fichier.

 
Sélectionnez
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")
Créé le 30 octobre 2009  par Thibaut Cuvelier

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.

 
Sélectionnez
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 // == false
Créé le 30 octobre 2009  par Thibaut Cuvelier

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

 
Sélectionnez
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 fichier

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

 
Sélectionnez

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.

 
Sélectionnez
qt_ntfs_permission_lookup++; // Activation de la vérification
qt_ntfs_permission_lookup--; // Désactivation de la vérification
Mis à jour le 7 mai 2012  par Thibaut Cuvelier

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

 
Sélectionnez
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à absolu
Créé le 30 octobre 2009  par Thibaut Cuvelier

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

 
Sélectionnez
QFileInfo file ("/Applications/Safari.app");

file.isBundle() // == true

file.bundleName() // == QString("Safari")
Créé le 30 octobre 2009  par Thibaut Cuvelier

La classe QFileInfo nous propose la méthode lastModified(), qui retourne la date de dernière modification sous forme de QDateTime.

 
Sélectionnez
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");
Mis à jour le 7 mai 2012  par Thibaut Cuvelier

Pour obtenir la taille d'un fichier, nul besoin d'utiliser l'artillerie lourde comme QFile : un objet QFileInfo peut retourner cette information

 
Sélectionnez
QFileInfo file ("~/file.ext");

qint64 size;

size = file.size();

Mais vous pouvez aussi utiliser QFile dans ce but.

 
Sélectionnez
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().

Mis à jour le 7 mai 2012  par Thibaut Cuvelier

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), avec path correspondant au chemin relatif ou absolu du fichier, ou bien addPaths(const QStringList & paths), avec paths correspondant à une QStringList de multiples chemins relatif 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 :

 
Sélectionnez
#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();
}
Créé le 7 mai 2012  par Louis du Verdier
  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006 - 2016 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.