QDir("/home/user/Documents")
QDir("C:/Documents and Settings")

QDir("images/landscape.png")

bool QDir::​makeAbsolute()

QDir(const QDir & dir)

QDir(const QString & path = QString())

QDir(const QString & path, const QString & nameFilter, SortFlags sort = SortFlags( Name | IgnoreCase ), Filters filters = AllEntries)

QString QDir::​path() const    //可能是相对路径，也可能是绝对路径

QString QDir::​absolutePath() const    //一定返回绝对路径

void QDir::​setPath(const QString & path)

bool QDir::​exists(const QString & name) const    //参数里既可以判断文件夹，也可以判断文件的存在性

bool QDir::​exists() const    //不带参数，判断 QDir 对象自身路径是否为存在的文件夹，只管文件夹！

QDir("Documents/Letters/Applications").dirName()   //返回 "Applications"

QDir().dirName()                                 //返回  "."

bool QDir::​cd(const QString & dirName)

bool QDir::​cdUp()

bool QDir::​mkdir(const QString & dirName) const    //创建新目录

bool QDir::​rename(const QString & oldName, const QString & newName) //重命名旧的目录

bool QDir::​rmdir(const QString & dirName) const    //删除一个空目录

bool QDir::​mkpath(const QString & dirPath) const

bool QDir::​rmpath(const QString & dirPath) const

bool QDir::​exists(const QString & name) const    //子文件夹或文件是否存在

bool QDir::​isReadable() const    //QDir对象当前目录是否有读权限，Linux系统有些目录普通用户不能读取

bool QDir::​isAbsolute() const    //QDir对象当前目录是否为绝对路径

bool QDir::​isRelative() const    //QDir对象当前目录是否为相对路径

bool QDir::​isRoot() const    //QDir对象当前目录是否为文件系统根

void QDir::​refresh() const

uint QDir::​count() const

QStringList QDir::​entryList(Filters filters = NoFilter, SortFlags sort = NoSort) const

QStringList QDir::​entryList(const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort) const

QFileInfoList QDir::​entryInfoList(Filters filters = NoFilter, SortFlags sort = NoSort) const

QFileInfoList QDir::​entryInfoList(const QStringList & nameFilters, Filters filters = NoFilter, SortFlags sort = NoSort) const

    QDir directory("Documents/Letters");

    QString path = directory.filePath("contents.txt");

    QString absolutePath = directory.absoluteFilePath("contents.txt");

    qDebug()<<directory.exists();

    qDebug()<<path;

    qDebug()<<absolutePath;

false
"Documents/Letters/contents.txt"
"D:/QtProjects/ch02/build-hellocreator-Desktop_Qt_5_4_0_MinGW_32bit-Debug/Documents/Letters/contents.txt"

bool QDir::​remove(const QString & fileName)

void QDir::​setNameFilters(const QStringList & nameFilters)

    QStringList filters;
    filters << "*.cpp" << "*.cxx" << "*.cc";
    dir.setNameFilters(filters);

bool QDir::​match(const QString & filter, const QString & fileName)   //静态函数

void QDir::​setFilter(Filters filters)

void QDir::​setSorting(SortFlags sort)

bool QDir::​setCurrent(const QString & path)

QString QCoreApplication::​applicationDirPath()    //静态函数

    QDir::setCurrent( QCoreApplication::applicationDirPath() );

    qDebug()<<QDir::currentPath();

QFileInfoList QDir::​drives()    //静态函数

QString QDir::​canonicalPath() const    //会自动判断路径是否真实存在

QString QDir::​cleanPath(const QString & path)    //静态函数

QString QDir::​fromNativeSeparators(const QString & pathName)    //静态函数，从本地化路径串转为 Qt 风格路径串

QString QDir::​toNativeSeparators(const QString & pathName)      //静态函数，将 Qt 风格路径串转为本地化路径串

bool QFileInfo::​isRelative() const

bool QFileInfo::​makeAbsolute()

QFileInfo()    //无参数，后面可以用 setFile() 函数设置文件名

QFileInfo(const QString & file)   //根据相对路径或绝对路径的字符串，访问文件

QFileInfo(const QFile & file)    //从一个 QFile对象提取该文件的信息

QFileInfo(const QDir & dir, const QString & file)  //根据路径对象和相对它的文件名，访问文件夹信息

QFileInfo(const QFileInfo & fileinfo)    //复制构造函数

void QFileInfo::​setFile(const QString & file)   //根据相对路径或绝对路径访问文件信息

void QFileInfo::​setFile(const QFile & file)     //从已有 QFile 对象提取出文件信息

void QFileInfo::​setFile(const QDir & dir, const QString & file) //根据路径对象和相对它的文件名，访问文件夹信息

bool QFileInfo::​exists() const

#ifdef Q_OS_UNIX

QFileInfo info1("/home/bob/bin/untabify");
info1.isSymLink();          // returns true
info1.absoluteFilePath();   // returns "/home/bob/bin/untabify"
info1.size();               // returns 56201
info1.symLinkTarget();      // returns "/opt/pretty++/bin/untabify"

QFileInfo info2(info1.symLinkTarget());
info2.isSymLink();          // returns false
info2.absoluteFilePath();   // returns "/opt/pretty++/bin/untabify"
info2.size();               // returns 56201

#endif

#ifdef Q_OS_WIN

QFileInfo info1("C:\\Documents and Settings\\Bob\\untabify.lnk");
info1.isSymLink();          // returns true
info1.absoluteFilePath();   // returns "C:/Documents and Settings/Bob/untabify.lnk"
info1.size();               // returns 743
info1.symLinkTarget();      // returns "C:/Pretty++/untabify"

QFileInfo info2(info1.symLinkTarget());
info2.isSymLink();          // returns false
info2.absoluteFilePath();   // returns "C:/Pretty++/untabify"
info2.size();               // returns 63942

#endif

QString QFileInfo::​filePath() const            //含路径和文件名，可能是相对的，也可能是绝对的路径文件名

QString QFileInfo::​absoluteFilePath() const    //返回绝对路径文件名

QString QFileInfo::​canonicalFilePath() const   //返回权威路径文件名

QString QFileInfo::​absolutePath() const   //返回绝对路径目录，不含文件名

QString QFileInfo::​canonicalPath() const  //返回权威路径目录，不含文件名

QString QFileInfo::​path() const      //返回当前路径文件名前面的路径部分

QString QFileInfo::​fileName() const  //返回文件名部分

QString QFileInfo::​baseName() const        //去除所有扩展名，得到基本名，如 "archive"

QString QFileInfo::​completeSuffix() const  //全部的扩展名，如 "tar.gz"

QString QFileInfo::​suffix() const          //最后一个扩展名，如 "gz"

QString QFileInfo::​completeBaseName() const  //去除最后一个扩展名的前面部分，如 "archive.tar"

bool QFileInfo::​permission(QFile::Permissions permissions) const

QFileInfo fi("/usr/bin/ping");
qDebug()<<fi.permission(QFileDevice::ReadUser
                  | QFileDevice::WriteUser
                  | QFileDevice::ExeUser);

QFile::Permissions QFileInfo::​permissions() const

extern Q_CORE_EXPORT int qt_ntfs_permission_lookup;

qt_ntfs_permission_lookup++;    // 开启权限检查

qt_ntfs_permission_lookup--;    // 重新关闭权限检查

void QFileInfo::​refresh()

void QFileInfo::​setCaching(bool enable)

#ifndef WIDGET_H

#define WIDGET_H

#include <QWidget>

namespace Ui {

class Widget;

}

class Widget : public QWidget

{

    Q_OBJECT

public:

    explicit Widget(QWidget *parent = 0);

    ~Widget();

private slots:

    void on_pushButtonGetWorkPath_clicked();

    void on_pushButtonSetWorkPath_clicked();

    void on_pushButtonEnvPaths_clicked();

    void on_pushButtonExist_clicked();

    void on_pushButtonIsRelative_clicked();

    void on_pushButtonShowAbsolute_clicked();

private:

    Ui::Widget *ui;

};

#endif // WIDGET_H

#include "widget.h"

#include "ui_widget.h"

#include <QDebug>

#include <QDir>         //目录浏览类

#include <QFileInfo>    //文件信息类

#include <QMessageBox>

Widget::Widget(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::Widget)

{

    ui->setupUi(this);

    //设置结果文本框为只读

    ui->plainTextEditResult->setReadOnly(true);

}

Widget::~Widget()

{

    delete ui;

}

void Widget::on_pushButtonGetWorkPath_clicked()

{

    //获取程序当前工作路径

    QString strWorkPath = QDir::currentPath();

    //显示到单行编辑控件

    ui->lineEditWorkPath->setText( strWorkPath );

}

void Widget::on_pushButtonSetWorkPath_clicked()

{

    //获取单行编辑器里的路径

    QString strNewPath = ui->lineEditWorkPath->text();

    //判断字符串是否为空

    if(strNewPath.length() < 1)

    {

        return;

    }

    //判断路径是否存在

    QDir dirNew(strNewPath);

    QString strResult;  //操作结果显示

    if( dirNew.exists() )

    {

        //存在该路径，设置为工作路径

        bool bRes = QDir::setCurrent( dirNew.path() );

        if( !bRes )

        {

            //设置工作路径失败

            strResult = tr("设置工作路径为 %1 失败。").arg(strNewPath);

            QMessageBox::warning(this, tr("设置错误"), strResult);

        }

        else

        {

            //设置成功

            strResult = tr("设置工作路径成功，新的路径为：\r\n%1").arg( QDir::currentPath() );

        }

    }

    else    //新路径不存在

    {

        strResult = tr("设置工作路径为 %1 失败，该路径不存在！").arg(strNewPath);

        QMessageBox::warning(this, tr("路径不存在"), strResult);

    }

    //显示结果信息

    ui->plainTextEditResult->setPlainText(strResult);

}

void Widget::on_pushButtonEnvPaths_clicked()

{

    QString strWorkPath = QDir::currentPath();  //应用程序的工作目录

    QString strAppPath = QCoreApplication::applicationDirPath();//可执行程序目录

    QString strHomePath = QDir::homePath();     //用户的主文件夹

    QString strRootPath = QDir::rootPath();     //应用程序所在文件系统的根分区

    QString strTempPath = QDir::tempPath();     //操作系统里默认的临时文件目录

    //构造结果串

    QString strResult;

    strResult += tr("工作路径：%1\r\n").arg(strWorkPath);

    strResult += tr("可执行程序目录：%1\r\n\r\n").arg(strAppPath);

    strResult += tr("用户主文件夹：%1\r\n").arg(strHomePath);

    strResult += tr("系统根目录：%1\r\n").arg(strRootPath);

    strResult += tr("临时目录：%1\r\n").arg(strTempPath);

    //显示

    ui->plainTextEditResult->setPlainText(strResult);

}

void Widget::on_pushButtonExist_clicked()

{

    //获取测试路径

    QString strTestPath = ui->lineEditTestPath->text();

    //判断字符串是否为空

    if(strTestPath.length() < 1)

    {

        return;

    }

    //不带参数的 dirWork 默认就是程序工作路径！

    QDir dirWork;

    //结果字符串

    QString strResult;

    //判断存在性，不带参数的 dirWork.exists() 只能判断文件夹

    //这里既需要判断文件夹，也要判断文件，因此把 strTestPath 作为参数传入来判断

    if( dirWork.exists( strTestPath ) )

    {

        strResult = tr("路径 %1 是存在的。").arg(strTestPath);

    }

    else

    {

        strResult = tr("路径 %1 不存在。").arg(strTestPath);

    }

    //显示

    ui->plainTextEditResult->setPlainText(strResult);

}

void Widget::on_pushButtonIsRelative_clicked()

{

    //获取测试路径

    QString strTestPath = ui->lineEditTestPath->text();

    //判断字符串是否为空

    if(strTestPath.length() < 1)

    {

        return;

    }

    //构造目录浏览对象

    QDir dirTest(strTestPath);

    //结果字符串

    QString strResult;

    //判断相对性

    if( dirTest.isRelative() )

    {

        //是相对路径

        strResult = tr("路径 %1 是相对路径").arg(strTestPath);

    }

    else

    {

        //是绝对路径

        strResult = tr("路径 %1 是绝对路径").arg(strTestPath);

    }

    //显示

    ui->plainTextEditResult->setPlainText(strResult);

}

void Widget::on_pushButtonShowAbsolute_clicked()

{

    //获取测试路径

    QString strTestPath = ui->lineEditTestPath->text();

    //判断字符串是否为空

    if(strTestPath.length() < 1)

    {

        return;

    }

    //构建目录浏览对象

    QDir dirTest(strTestPath);

    //结果字符串

    QString strResult;

    //获取绝对路径

    strResult = tr("测试路径 %1 的绝对路径为：%2")

            .arg(strTestPath).arg( dirTest.absolutePath() );

    //显示

    ui->plainTextEditResult->setPlainText(strResult);

}

D:/QtProjects/ch07/build-paths-Desktop_Qt_5_4_0_MinGW_32bit-Debug

工作路径：D:/QtProjects/ch07/build-paths-Desktop_Qt_5_4_0_MinGW_32bit-Debug
可执行程序目录： D:/QtProjects/ch07/build-paths-Desktop_Qt_5_4_0_MinGW_32bit-Debug/debug

用户主文件夹：C:/Documents and Settings/Administrator
系统根目录：C:/
临时目录：C:/Documents and Settings/Administrator/Local Settings/Temp

QListWidgetItem(const QIcon & icon, const QString & text, QListWidget * parent = 0, int type = Type)

void QListWidget::​addItem(QListWidgetItem * item)

void QListWidget::​currentItemChanged(QListWidgetItem * current, QListWidgetItem * previous)

void QListWidget::​itemClicked(QListWidgetItem * item)

void QListWidget::​itemDoubleClicked(QListWidgetItem * item)

void QListWidget::​clear()

#ifndef WIDGET_H

#define WIDGET_H

#include <QWidget>

#include <QIcon>        //图标

#include <QListWidget>  //列表控件以及条目

#include <QDir>         //目录浏览

#include <QFileInfo>    //文件信息

namespace Ui {

class Widget;

}

class Widget : public QWidget

{

    Q_OBJECT

public:

    explicit Widget(QWidget *parent = 0);

    ~Widget();

    //条目类型枚举

    enum ITypes{ IDriver = 1999, IFolder = 2000, IFile = 2001 };

private slots:

    void on_pushButtonEnter_clicked();

    void on_pushButtonDrivers_clicked();

    void on_pushButtonParent_clicked();

    void on_listWidget_itemDoubleClicked(QListWidgetItem *item);

    void on_listWidget_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous);

private:

    Ui::Widget *ui;

    //图标

    QIcon m_iconDriver; //分区根

    QIcon m_iconFolder; //文件夹

    QIcon m_iconFile;   //文件

    //当前目录

    QDir m_dirCur;

    //根据指定存在的目录，列举条目到列表控件

    void ShowItems(const QDir& dir);

    //根据 fi 获取文件信息，返回字符串

    QString GetFileInfo(const QFileInfo& fi);

    //根据 fi 获取文件夹信息，返回字符串

    QString GetFolderInfo(const QFileInfo& fi);

};

#endif // WIDGET_H

#include "widget.h"

#include "ui_widget.h"

#include <QDebug>

#include <QMessageBox>  //消息框

#include <QDesktopServices> //打开本地文件或 URL

#include <QDateTime>    //日期时间

Widget::Widget(QWidget *parent) :

    QWidget(parent),

    ui(new Ui::Widget)

{

    ui->setupUi(this);

    //设置结果信息框只读

    ui->plainTextEditInfo->setReadOnly(true);

    //图标

    m_iconDriver = QIcon(":/images/driver.png");

    m_iconFolder = QIcon(":/images/folder.png");

    m_iconFile = QIcon(":/images/file.png");

    //罗列分区根

    on_pushButtonDrivers_clicked();

}

Widget::~Widget()

{

    delete ui;

}

//根据目录列出条目到列表控件

void Widget::ShowItems(const QDir &dir)

{

    if( ! dir.exists())

    {

        //如果不存在就直接返回

        return;

    }

    //获取所有条目，目录排在前面

    QFileInfoList li = dir.entryInfoList(QDir::NoFilter, QDir::DirsFirst);

    //计数

    int nCount = li.count();

    //清空列表控件

    ui->listWidget->clear();

    //逐个添加

    for(int i=0; i<nCount; i++)

    {

        //不含路径的名字

        QString name = li[i].fileName();

        //判断是文件夹还是文件

        if(li[i].isDir())

        {

            //文件夹条目

            QListWidgetItem *itemFolder =

                    new QListWidgetItem(m_iconFolder, name, NULL, IFolder);

            //添加

            ui->listWidget->addItem(itemFolder);

        }

        else

        {

            //文件条目

            QListWidgetItem *itemFile =

                    new QListWidgetItem(m_iconFile, name, NULL, IFile);

            //添加

            ui->listWidget->addItem(itemFile);

        }

    }

}

void Widget::on_pushButtonEnter_clicked()

{

    //新目录

    QString strNewDir = ui->lineEditDir->text();

    QDir dirNew(strNewDir);

    //判断新目录是否存在

    if( dirNew.exists() )

    {

        //存在目录，使用权威路径，避免 Windows 系统进入的 "/" 的 bug

        m_dirCur = QDir( dirNew.canonicalPath() );

        //更新列表控件

        ShowItems(m_dirCur);

        //使用绝对路径显示

        ui->lineEditDir->setText(m_dirCur.absolutePath());

        //结果信息

        ui->plainTextEditInfo->setPlainText(tr("进入成功"));

    }

    else

    {

        //不存在目录

        QMessageBox::warning(this, tr("目录不存在"), tr("目录 %1 不存在").arg(strNewDir));

    }

}

void Widget::on_pushButtonDrivers_clicked()

{

    //获取磁盘根分区

    QFileInfoList fil = QDir::drives();

    //手动添加本程序资源根

    fil.append( QFileInfo(":/") );

    //分区根计数

    int nCount = fil.count();

    //清空列表控件

    ui->listWidget->clear();

    //逐个添加条目

    for(int i=0; i<nCount; i++)

    {

        //分区根路径，全部用绝对路径显示

        QString strPath = fil[i].absolutePath();

        //新建条目

        QListWidgetItem *item =

                new QListWidgetItem(m_iconDriver, strPath, NULL, IDriver);

        //添加到列表控件

        ui->listWidget->addItem(item);

    }

    //当前目录设为系统根

    m_dirCur = QDir::root();

    //单行编辑控件文件

    ui->lineEditDir->setText( m_dirCur.absolutePath() );

    //结果显示

    ui->plainTextEditInfo->setPlainText(tr("已获取分区根"));

}

void Widget::on_pushButtonParent_clicked()

{

    if( m_dirCur.cdUp() )

    {

        //单行编辑控件更新，显示绝对路径

        ui->lineEditDir->setText( m_dirCur.absolutePath() );

        //列表更新

        ShowItems(m_dirCur);

        ui->plainTextEditInfo->setPlainText(tr("进入父目录成功"));

    }

    else

    {

        ui->plainTextEditInfo->setPlainText(tr("已到根目录"));

    }

}

void Widget::on_listWidget_itemDoubleClicked(QListWidgetItem *item)

{

    //判断 item 的类型

    int theType = item->type();

    if( IDriver == theType )    //如果是分区根

    {

        //根路径

        QString strFullPath = item->text();

        //设置当前目录

        m_dirCur = QDir( strFullPath );

        //更新单行编辑控件，显示绝对路径

        ui->lineEditDir->setText( m_dirCur.absolutePath() );

        //更新列表控件

        ShowItems(m_dirCur);

    }

    else if( IFolder == theType )   //如果是文件夹

    {

        //先对 . 和 .. 做排除

        QString strName = item->text();

        if( tr(".") == strName)

        {

            //不需要处理，还是当前目录

            return;

        }

        else if ( tr("..") == strName )

        {

            //切换父目录

            on_pushButtonParent_clicked();

            //返回

            return;

        }

        //正常的子文件夹处理

        //完整路径

        QString strFullPath = m_dirCur.absolutePath() + tr("/") + strName;

        strFullPath = QDir::cleanPath(strFullPath); //清理多余的斜杠

        //切换路径

        m_dirCur = QDir(strFullPath);

        //更新单行编辑控件，显示绝对路径

        ui->lineEditDir->setText(m_dirCur.absolutePath());

        //更新列表控件

        ShowItems(m_dirCur);

    }

    else    //普通文件

    {

        //拼接出路径字符串

        QString strFilePath = m_dirCur.absolutePath() + tr("/")  + item->text();

        strFilePath = QDir::cleanPath(strFilePath); //清理多余的斜杠

        //如果不是内嵌资源文件，是本地文件系统的

        if( ! strFilePath.startsWith( tr(":") ))

        {

            //调用系统浏览器打开

            QDesktopServices::openUrl( QUrl::fromLocalFile(strFilePath) );

        }

    }

}

void Widget::on_listWidget_currentItemChanged(QListWidgetItem *current, QListWidgetItem *previous)

{

    //如果当前条目为空则返回

    if( NULL == current )

    {

        return;

    }

    //条目信息对象

    QFileInfo fi;

    //记录信息字符串

    QString strResult;

    //条目类型

    int theType = current->type();

    //条目名称

    QString strName = current->text();

    //判断类型

    if( IDriver == theType )    //分区根

    {

        //分区根路径

        fi = QFileInfo( strName );

        if( strName.startsWith( tr(":") ) )

        {

            strResult += tr("资源根 %1").arg(strName); //显示绝对路径

        }

        else

        {

            strResult += tr("分区根 %1").arg(strName); //显示绝对路径

        }

    }

    else if( IFolder == theType )   //文件夹

    {

        //完整路径

        QString strFullPath = m_dirCur.absolutePath() + tr("/") + strName;

        strFullPath = QDir::cleanPath(strFullPath); //清理多余的斜杠

        strResult += tr("文件夹 %1\r\n").arg(strFullPath); //显示绝对路径

        //获取信息，添加到结果串

        fi = QFileInfo(strFullPath);        

        strResult += GetFolderInfo(fi);

    }

    else    //文件

    {

        //完整文件名

        QString strFilePath = m_dirCur.absolutePath() + tr("/") + strName;

        strFilePath = QDir::cleanPath(strFilePath); //清理多余的斜杠

        strResult += tr("文件 %1\r\n").arg(strFilePath); //显示绝对路径

        //获取文件信息，添加到结果串

        fi = QFileInfo(strFilePath);

        strResult += GetFileInfo(fi);

    }

    //显示结果信息

    ui->plainTextEditInfo->setPlainText(strResult);

}

//获取文件夹信息字符串

QString Widget::GetFolderInfo(const QFileInfo &fi)

{

    QString strResult;  //用于返回的串

    //判断文件夹信息

    if(fi.isReadable()) //是否可读

    {

        strResult += tr("可读：是\r\n");

    }

    else

    {

        strResult += tr("可读：否\r\n");

    }

    if(fi.isWritable()) //是否可写

    {

        strResult += tr("可写：是\r\n");

    }

    else

    {

        strResult += tr("可写：否\r\n");

    }

    //时间

    QDateTime dtCreate = fi.created();

    QDateTime dtModify = fi.lastModified();

    strResult += tr("创建时间：%1\r\n").arg(dtCreate.toString("yyyy-MM-dd HH:mm:ss"));

    strResult += tr("修改时间：%1\r\n").arg(dtModify.toString("yyyy-MM-dd HH:mm:ss"));

    //返回

    return strResult;

}

//返回文件信息字符串

QString Widget::GetFileInfo(const QFileInfo &fi)

{

    QString strResult;  //用于返回的串

    //判断文件信息

    if(fi.isReadable())

    {

        strResult += tr("可读：是\r\n");

    }

    else

    {

        strResult += tr("可读：否\r\n");

    }

    if(fi.isWritable())

    {

        strResult += tr("可写：是\r\n");

    }

    else

    {

        strResult += tr("可写：否\r\n");

    }

    if(fi.isExecutable())

    {

        strResult += tr("可执行：是\r\n");

    }

    else

    {

        strResult += tr("可执行：否\r\n");

    }

    //类型

    strResult += tr("类型：%1\r\n").arg(fi.suffix());

    //大小

    strResult += tr("大小：%1 B\r\n").arg(fi.size());

    //时间

    QDateTime dtCreate = fi.created();

    QDateTime dtModify = fi.lastModified();

    strResult += tr("创建时间：%1\r\n").arg(dtCreate.toString("yyyy-MM-dd HH:mm:ss"));

    strResult += tr("修改时间：%1\r\n").arg(dtModify.toString("yyyy-MM-dd HH:mm:ss"));

    //返回

    return strResult;

}