QDir Class
La clase QDir permite acceder a las estructuras de directorios y a su contenido. Más información...
| Encabezado: | #include <QDir> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
- Lista de todos los miembros, incluidos los heredados
- QDir forma parte de las clases de entrada/salida y redes, y de las clases compartidas implícitamente.
Nota: Todas las funciones de esta clase son reentrantes.
Comparaciones de QDir
| Categoría | Tipos comparables |
|---|---|
| igualdad | QDir |
Tipos públicos
| enum | Filter { Dirs, AllDirs, Files, Drives, NoSymLinks, …, CaseSensitive } |
| flags | Filters |
| enum | SortFlag { Name, Time, Size, Type, Unsorted, …, LocaleAware } |
| flags | SortFlags |
Funciones públicas
| QDir(const QString &path = QString()) | |
(since 6.0) | QDir(const std::filesystem::path &path) |
| QDir(const QString &path, const QString &nameFilter, QDir::SortFlags sort = SortFlags(Name | IgnoreCase), QDir::Filters filters = AllEntries) | |
(since 6.0) | QDir(const std::filesystem::path &path, const QString &nameFilter, QDir::SortFlags sort = SortFlags(Name | IgnoreCase), QDir::Filters filters = AllEntries) |
| QDir(const QDir &dir) | |
| ~QDir() | |
| QString | absoluteFilePath(const QString &fileName) const |
| QString | absolutePath() const |
| QString | canonicalPath() const |
| bool | cd(const QString &dirName) |
| bool | cdUp() |
| qsizetype | count() const |
| QString | dirName() const |
| QFileInfoList | entryInfoList(const QStringList &nameFilters, QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const |
| QFileInfoList | entryInfoList(QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const |
| QStringList | entryList(const QStringList &nameFilters, QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const |
| QStringList | entryList(QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const |
| bool | exists(const QString &name) const |
| bool | exists() const |
| QString | filePath(const QString &fileName) const |
(since 6.0) std::filesystem::path | filesystemAbsolutePath() const |
(since 6.0) std::filesystem::path | filesystemCanonicalPath() const |
(since 6.0) std::filesystem::path | filesystemPath() const |
| QDir::Filters | filter() const |
| bool | isAbsolute() const |
| bool | isEmpty(QDir::Filters filters = Filters(AllEntries | NoDotAndDotDot)) const |
| bool | isReadable() const |
| bool | isRelative() const |
| bool | isRoot() const |
| bool | makeAbsolute() |
| bool | mkdir(const QString &dirName, std::optional<QFileDevice::Permissions> permissions = std::nullopt) const |
| bool | mkpath(const QString &dirPath, std::optional<QFileDevice::Permissions> permissions = std::nullopt) const |
| QStringList | nameFilters() const |
| QString | path() const |
| void | refresh() const |
| QString | relativeFilePath(const QString &fileName) const |
| bool | remove(const QString &fileName) |
| bool | removeRecursively() |
| bool | rename(const QString &oldName, const QString &newName) |
| bool | rmdir(const QString &dirName) const |
| bool | rmpath(const QString &dirPath) const |
| void | setFilter(QDir::Filters filters) |
| void | setNameFilters(const QStringList &nameFilters) |
| void | setPath(const QString &path) |
(since 6.0) void | setPath(const std::filesystem::path &path) |
| void | setSorting(QDir::SortFlags sort) |
| QDir::SortFlags | sorting() const |
| void | swap(QDir &other) |
| QDir & | operator=(QDir &&other) |
| QDir & | operator=(const QDir &dir) |
| QString | operator[](qsizetype pos) const |
Miembros públicos estáticos
| void | addSearchPath(const QString &prefix, const QString &path) |
(since 6.0) void | addSearchPath(const QString &prefix, const std::filesystem::path &path) |
| QString | cleanPath(const QString &path) |
| QDir | current() |
| QString | currentPath() |
| QFileInfoList | drives() |
| QString | fromNativeSeparators(const QString &pathName) |
| QDir | home() |
| QString | homePath() |
| bool | isAbsolutePath(const QString &path) |
| bool | isRelativePath(const QString &path) |
| QChar | listSeparator() |
| bool | match(const QString &filter, const QString &fileName) |
| bool | match(const QStringList &filters, const QString &fileName) |
| QDir | root() |
| QString | rootPath() |
| QStringList | searchPaths(const QString &prefix) |
| QChar | separator() |
| bool | setCurrent(const QString &path) |
| void | setSearchPaths(const QString &prefix, const QStringList &searchPaths) |
| QDir | temp() |
| QString | tempPath() |
| QString | toNativeSeparators(const QString &pathName) |
Elementos no miembros relacionados
| bool | operator!=(const QDir &lhs, const QDir &rhs) |
| bool | operator==(const QDir &lhs, const QDir &rhs) |
Descripción detallada
Un QDir se utiliza para manipular nombres de ruta, acceder a información relativa a rutas y archivos, y manipular el sistema de archivos subyacente. También se puede utilizar para acceder al sistema de recursos de Qt.
Qt utiliza «/» como separador universal de directorios, del mismo modo que «/» se utiliza como separador de rutas en las URL. Si siempre utilizas «/» como separador de directorios, Qt traducirá tus rutas para que se ajusten al sistema operativo subyacente.
Un QDir puede apuntar a un archivo utilizando una ruta relativa o absoluta. Las rutas absolutas comienzan con el separador de directorios (opcionalmente precedido por una especificación de unidad en Windows). Los nombres de archivo relativos comienzan con un nombre de directorio o un nombre de archivo y especifican una ruta relativa al directorio actual.
Ejemplos de rutas absolutas:
En Windows, el segundo ejemplo anterior se traducirá a C:\Users cuando se utilice para acceder a archivos.
Ejemplos de rutas relativas:
QDir("images/landscape.png");Puedes utilizar las funciones ` isRelative()` o ` isAbsolute()` para comprobar si un `QDir` está utilizando una ruta de archivo relativa o absoluta. Llama a ` makeAbsolute()` para convertir un `QDir` relativo en uno absoluto.
Nota: Las rutas que comienzan con dos puntos (:) siempre se consideran absolutas, ya que indican un « QResource ».
Navegación y operaciones con directorios
La ruta de un directorio se puede obtener con la función path() y se puede establecer una nueva ruta con la función setPath(). La ruta absoluta a un directorio se obtiene llamando a absolutePath().
El nombre de un directorio se obtiene mediante la función ` dirName()`. Normalmente, esta función devuelve el último elemento de la ruta absoluta que especifica la ubicación del directorio. Sin embargo, también puede devolver «.» si el objeto `QDir` representa el directorio actual.
La ruta de un directorio también se puede modificar con las funciones ` cd()` y ` cdUp()`, que funcionan como los conocidos comandos del shell. Cuando se invoca a ` cd()` con el nombre de un directorio existente, el objeto `QDir` cambia de directorio para que represente ese directorio en su lugar. La función cdUp() cambia el directorio del objeto QDir para que apunte a su directorio padre; es decir, cd("..") es equivalente a cdUp().
Los directorios se pueden crear con ` mkdir()`, renombrar con ` rename()` y eliminar con ` rmdir()`.
Se puede comprobar si existe un directorio con un nombre determinado utilizando exists(), y las propiedades de un directorio se pueden comprobar con isReadable(), isAbsolute(), isRelative() y isRoot().
La función refresh() vuelve a leer los datos del directorio desde el disco.
Archivos y contenido de los directorios
Los directorios contienen una serie de entradas que representan archivos, directorios y enlaces simbólicos. La función ` count()` devuelve el número de entradas de un directorio. Con la función ` entryList()` se puede obtener una lista de cadenas con los nombres de todas las entradas de un directorio. Si necesitas información sobre cada entrada, utiliza la función ` entryInfoList()` para obtener una lista de objetos ` QFileInfo `.
Las rutas a archivos y directorios dentro de un directorio se pueden construir utilizando filePath() y absoluteFilePath(). La función filePath() devuelve una ruta al archivo o directorio especificado relativa a la ruta del objeto QDir; absoluteFilePath() devuelve una ruta absoluta al archivo o directorio especificado. Ninguna de estas funciones comprueba la existencia de archivos o directorios; solo construyen rutas.
QDir directory("Documents/Letters");
QString path = directory.filePath("contents.txt");
QString absolutePath = directory.absoluteFilePath("contents.txt");Los archivos se pueden eliminar utilizando la función « remove »(). Los directorios no se pueden eliminar de la misma forma que los archivos; en su lugar, utilice « rmdir »() para eliminarlos.
Es posible reducir el número de entradas devueltas por entryList() y entryInfoList() aplicando filtros a un objeto QDir. Se puede aplicar un filtro de nombre para especificar un patrón con comodines con el que deben coincidir los nombres de los archivos, un filtro de atributos que seleccione propiedades de las entradas y pueda distinguir entre archivos y directorios, y un orden de clasificación.
Los filtros de nombre son listas de cadenas que se pasan a setNameFilters(). Los filtros de atributos consisten en una combinación OR bit a bit de Filters, y se especifican al llamar a setFilter(). El orden de clasificación se especifica utilizando setSorting() con una combinación OR bit a bit de SortFlags.
Se puede comprobar si un nombre de archivo coincide con un filtro utilizando la función match().
Los indicadores de filtro y orden de clasificación también pueden especificarse al llamar a entryList() y entryInfoList() para anular el comportamiento definido previamente.
El directorio actual y otras rutas especiales
El acceso a algunos directorios habituales se proporciona mediante una serie de funciones estáticas que devuelven objetos QDir. También existen funciones correspondientes a estas que devuelven cadenas:
| QDir | QString | Valor devuelto |
|---|---|---|
| current() | currentPath() | El directorio de trabajo de la aplicación |
| home() | homePath() | El directorio de inicio del usuario |
| root() | rootPath() | El directorio raíz |
| temp() | tempPath() | El directorio temporal del sistema |
La función estática ` setCurrent()` también se puede utilizar para establecer el directorio de trabajo de la aplicación.
Si desea localizar el directorio que contiene el ejecutable de la aplicación, consulte QCoreApplication::applicationDirPath().
La función estática drives() proporciona una lista de directorios raíz para cada dispositivo que contenga un sistema de archivos. En sistemas Unix, devuelve una lista que contiene un único directorio raíz «/»; en Windows, la lista suele contener C:/ y, posiblemente, otras letras de unidad como D:/, dependiendo de la configuración del sistema del usuario.
Manipulación de rutas y cadenas de caracteres
Las rutas que contengan elementos «.» —que hacen referencia al directorio actual en ese punto de la ruta—, elementos «..» —que hacen referencia al directorio padre— y enlaces simbólicos pueden reducirse a una forma canónica utilizando la función canonicalPath().
Las rutas también pueden simplificarse utilizando cleanPath() para eliminar los elementos redundantes «/» y «..».
A veces es necesario poder mostrar una ruta en la representación nativa de la plataforma del usuario. La función estática toNativeSeparators() devuelve una copia de la ruta especificada en la que cada separador de directorios se sustituye por el separador adecuado para el sistema operativo subyacente.
Ejemplos
Comprobar si existe un directorio:
(También podríamos utilizar una de las funciones estáticas de conveniencia QFileInfo::exists() o QFile::exists().)
Recorrer directorios y leer un archivo:
QDir dir = QDir::root(); // "/"
if (!dir.cd("tmp")) { // "/tmp"
qWarning("Cannot find the \"/tmp\" directory");
} else {
QFile file(dir.filePath("ex1.txt")); // "/tmp/ex1.txt"
if (!file.open(QIODevice::ReadWrite))
qWarning("Cannot create the file %s", qPrintable(file.fileName()));
}Un programa que muestra todos los archivos del directorio actual (excluyendo los enlaces simbólicos), ordenados por tamaño, empezando por el más pequeño:
#include <QDir>
#include <iostream>
#include <QCoreApplication>
int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
QDir dir;
dir.setFilter(QDir::Files | QDir::Hidden | QDir::NoSymLinks);
dir.setSorting(QDir::Size | QDir::Reversed);
QFileInfoList list = dir.entryInfoList();
std::cout << " Bytes Filename" << std::endl;
for (int i = 0; i < list.size(); ++i) {
QFileInfo fileInfo = list.at(i);
std::cout << qPrintable(QString("%1 %2").arg(fileInfo.size(), 10)
.arg(fileInfo.fileName()));
std::cout << std::endl;
}
return 0;
}Cuestiones específicas de cada plataforma
En Android, existen algunas limitaciones a la hora de gestionar las URI de contenido:
- Es posible que se necesiten permisos de acceso, para lo cual se debe solicitar al usuario a través de la clase ` QFileDialog `, que implementa el selector de archivos nativo de Android.
- Intenta seguir las directrices de almacenamiento con ámbito (Scoped storage), como el uso de directorios específicos de la aplicación en lugar de otros directorios externos públicos. Para obtener más información, consulta también las prácticas recomendadas de almacenamiento.
- Debido al diseño de las API de Qt (p. ej., QFile), no es posible integrar completamente estas últimas API con las API de MediaStore de Android.
Véase también QFileInfo, QFile, QFileDialog, QCoreApplication::applicationDirPath() y el ejemplo «Fetch More».
Documentación sobre los tipos de miembros
enum QDir::Filter
flags QDir::Filters
Esta enumeración describe las opciones de filtrado disponibles para QDir; por ejemplo, para entryList() y entryInfoList(). El valor del filtro se especifica combinando valores de la siguiente lista mediante el operador OR bit a bit:
| Constante | Valor | Descripción |
|---|---|---|
QDir::Dirs | 0x001 | Muestra los directorios que coinciden con los filtros. |
QDir::AllDirs | 0x400 | Muestra todos los directorios; es decir, no aplica los filtros a los nombres de los directorios. |
QDir::Files | 0x002 | Mostrar archivos. |
QDir::Drives | 0x004 | Mostrar unidades de disco (se ignora en Unix). |
QDir::NoSymLinks | 0x008 | No mostrar enlaces simbólicos (se ignoran en los sistemas operativos que no admiten enlaces simbólicos). |
QDir::NoDotAndDotDot | NoDot | NoDotDot | No mostrar las entradas especiales «.» y «..». |
QDir::NoDot | 0x2000 | No mostrar la entrada especial «.». |
QDir::NoDotDot | 0x4000 | No mostrar la entrada especial «..». |
QDir::AllEntries | Dirs | Files | Drives | Muestra directorios, archivos, unidades y enlaces simbólicos (esto no muestra los enlaces simbólicos rotos a menos que se especifique «System»). |
QDir::Readable | 0x010 | Muestra los archivos a los que la aplicación tiene acceso de lectura. El valor «Readable» debe combinarse con «Dirs» o «Files». |
QDir::Writable | 0x020 | Muestra los archivos a los que la aplicación tiene acceso de escritura. El valor «Writable» debe combinarse con «Dirs» o «Files». |
QDir::Executable | 0x040 | Muestra los archivos a los que la aplicación tiene acceso de ejecución. El valor «Ejecutable» debe combinarse con «Dirs» o «Files». |
QDir::Hidden | 0x100 | Muestra los archivos ocultos (en Unix, los archivos que empiezan por «.»). |
QDir::System | 0x200 | Mostrar los archivos del sistema (en Unix, se incluyen los FIFO, los sockets y los archivos de dispositivo; en Windows, se incluyen los archivos « .lnk »). |
QDir::CaseSensitive | 0x800 | El filtro debe distinguir entre mayúsculas y minúsculas. |
Las funciones que utilizan valores de la enumeración «Filter» para filtrar listas de archivos y directorios incluirán enlaces simbólicos a archivos y directorios, a menos que se establezca el valor «NoSymLinks».
Un ` QDir ` creado de forma predeterminada no filtrará los archivos en función de sus permisos, por lo que ` entryList()` y ` entryInfoList()` devolverán todos los archivos que sean legibles, escribibles, ejecutables o cualquier combinación de los tres. Esto hace que el valor predeterminado sea fácil de escribir y, al mismo tiempo, útil.
Por ejemplo, al establecer los indicadores Readable, Writable y Files, se permite listar todos los archivos a los que la aplicación tiene acceso de lectura, de escritura o ambos. Si también se incluyen en esta combinación los indicadores Dirs y Drives, se podrán listar todas las unidades, todos los directorios, todos los archivos que la aplicación pueda leer, escribir o ejecutar, así como los enlaces simbólicos a dichos archivos o directorios.
Para recuperar los permisos de un directorio, utiliza la función ` entryInfoList()` para obtener los objetos ` QFileInfo ` asociados y, a continuación, utiliza la función ` QFileInfo::permissions()` para obtener los permisos y la propiedad de cada archivo.
El tipo «Filters» es un typedef de QFlags<Filter>. Almacena una combinación OR de valores de «Filter».
enum QDir::SortFlag
flags QDir::SortFlags
Esta enumeración describe las opciones de ordenación disponibles para ` QDir`, por ejemplo, para ` entryList()` y ` entryInfoList()`. El valor de ordenación se especifica combinando mediante la operación OR los valores de la siguiente lista:
| Constante | Valor | Descripción |
|---|---|---|
QDir::Name | 0x00 | Ordenar por nombre. |
QDir::Time | 0x01 | Ordenar por fecha (fecha de modificación). |
QDir::Size | 0x02 | Ordenar por tamaño de archivo. |
QDir::Type | 0x80 | Ordenar por tipo de archivo (extensión). |
QDir::Unsorted | 0x03 | No ordenar. |
QDir::NoSort | -1 | Por defecto, no se ordena. |
QDir::DirsFirst | 0x04 | Mostrar primero los directorios y después los archivos. |
QDir::DirsLast | 0x20 | Poner primero los archivos y luego los directorios. |
QDir::Reversed | 0x08 | Invertir el orden de ordenación. |
QDir::IgnoreCase | 0x10 | Ordenar sin distinguir entre mayúsculas y minúsculas. |
QDir::LocaleAware | 0x40 | Ordenar los elementos según la configuración regional actual. |
Solo se puede especificar una de las cuatro primeras opciones.
Si se especifican tanto DirsFirst como Reversed, los directorios seguirán apareciendo primero, pero en orden inverso; los archivos se mostrarán después de los directorios, también en orden inverso.
El tipo SortFlags es un typedef de QFlags<SortFlag>. Almacena una combinación OR de valores de SortFlag.
Documentación de las funciones miembro
QDir::QDir(const QString &path = QString())
Crea un objeto QDir que apunta al directorio indicado path. Si path está vacío, se utiliza el directorio de trabajo del programa («.»).
Véase también currentPath().
[since 6.0] QDir::QDir(const std::filesystem::path &path)
Crea un objeto QDir que apunta al directorio indicado en « path ». Si «path» está vacío, se utiliza el directorio de trabajo del programa («.»).
Esta función se introdujo en Qt 6.0.
Véase también currentPath().
QDir::QDir(const QString &path, const QString &nameFilter, QDir::SortFlags sort = SortFlags(Name | IgnoreCase), QDir::Filters filters = AllEntries)
Crea un QDir con la ruta path, que filtra sus entradas por nombre utilizando nameFilter y por atributos utilizando filters. Además, ordena los nombres utilizando sort.
El valor por defecto de nameFilter es una cadena vacía, lo que no excluye nada; el valor por defecto de filters es AllEntries, lo que tampoco excluye nada. El valor por defecto de sort es Name | IgnoreCase, es decir, ordena por nombre sin distinguir entre mayúsculas y minúsculas.
Si path es una cadena vacía, QDir utiliza «.» (el directorio actual). Si nameFilter es una cadena vacía, QDir utiliza el filtro de nombre «*» (todos los archivos).
Nota: No es necesario quepath exista.
Véase también exists(), setPath(), setNameFilters(), setFilter() y setSorting().
[since 6.0] QDir::QDir(const std::filesystem::path &path, const QString &nameFilter, QDir::SortFlags sort = SortFlags(Name | IgnoreCase), QDir::Filters filters = AllEntries)
Crea un QDir con la ruta path, que filtra sus entradas por nombre utilizando nameFilter y por atributos utilizando filters. Además, ordena los nombres utilizando sort.
El valor por defecto de nameFilter es una cadena vacía, lo que no excluye nada; el valor por defecto de filters es AllEntries, lo que tampoco excluye nada. El valor por defecto de sort es Name | IgnoreCase, es decir, ordenar por nombre sin distinguir entre mayúsculas y minúsculas.
Si path está vacío, QDir utiliza «.» (el directorio actual). Si nameFilter es una cadena vacía, QDir utiliza el filtro de nombres «*» (todos los archivos).
Nota: No es necesario que existapath.
Esta función se introdujo en Qt 6.0.
Véase también exists(), setPath(), setNameFilters(), setFilter() y setSorting().
QDir::QDir(const QDir &dir)
Crea un objeto QDir que es una copia del objeto QDir correspondiente al directorio dir.
Véase también operator=().
[noexcept] QDir::~QDir()
Destruye el objeto « QDir » y libera sus recursos. Esto no tiene ningún efecto sobre el directorio subyacente en el sistema de archivos.
QString QDir::absoluteFilePath(const QString &fileName) const
Devuelve la ruta absoluta de un archivo en el directorio. No comprueba si el archivo existe realmente en el directorio; véase, no obstante, exists(). No se eliminan los separadores múltiples redundantes ni los directorios «.» y «..» en fileName (véase cleanPath()).
Véase también relativeFilePath(), filePath() y canonicalPath().
QString QDir::absolutePath() const
Devuelve la ruta absoluta (una ruta que comienza por «/» o por la especificación de una unidad), que puede contener enlaces simbólicos, pero nunca contiene caracteres redundantes como «.», «..» ni separadores múltiples.
Véase también setPath(), canonicalPath(), exists(), cleanPath(), dirName() y absoluteFilePath().
[static] void QDir::addSearchPath(const QString &prefix, const QString &path)
Añade path a la ruta de búsqueda de prefix.
Véase también setSearchPaths().
[static, since 6.0] void QDir::addSearchPath(const QString &prefix, const std::filesystem::path &path)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
QString QDir::canonicalPath() const
Devuelve la ruta canónica, es decir, una ruta sin enlaces simbólicos ni elementos redundantes «.» o «..».
En sistemas que no tienen enlaces simbólicos, esta función siempre devolverá la misma cadena que devuelve absolutePath(). Este método devuelve una cadena vacía si la entrada no existe, no es accesible (por ejemplo, el usuario actual no tiene acceso a una ruta de directorio) o se produce un error al canonizar la ruta (normalmente debido a enlaces simbólicos colgados).
Ejemplo:
QString bin = "/local/bin"; // where /local/bin is a symlink to /usr/bin
QDir binDir(bin);
QString canonicalBin = binDir.canonicalPath();
// canonicalBin now equals "/usr/bin"
QString ls = "/local/bin/ls"; // where ls is the executable "ls"
QDir lsDir(ls);
QString canonicalLs = lsDir.canonicalPath();
// canonicalLS now equals "/usr/bin/ls".Véase también path(), absolutePath(), exists(), cleanPath(), dirName() y absoluteFilePath().
bool QDir::cd(const QString &dirName)
Cambia el directorio de QDir a dirName.
Devuelve ` true ` si el nuevo directorio existe; en caso contrario, devuelve ` false`. Ten en cuenta que la operación lógica `cd()` no se lleva a cabo si el nuevo directorio no existe.
Llamar a cd("..") equivale a llamar a cdUp().
Véase también cdUp(), isReadable(), exists() y path().
bool QDir::cdUp()
Cambia de directorio subiendo un nivel desde el directorio actual de QDir.
Devuelve ` true ` si el nuevo directorio existe; en caso contrario, devuelve ` false`. Ten en cuenta que la operación lógica `cdUp()` no se lleva a cabo si el nuevo directorio no existe.
Nota: En Android, esto no es compatible con los URI de contenido. Para obtener más información, consulta DocumentFile.getParentFile().
Véase también cd(), isReadable(), exists() y path().
[static] QString QDir::cleanPath(const QString &path)
Devuelve ` path ` con los separadores de directorios normalizados (es decir, los separadores nativos de la plataforma se convierten a «/») y los redundantes eliminados, y los «.» y «..» resueltos (en la medida de lo posible).
Se conservan los enlaces simbólicos. Esta función no devuelve la ruta canónica, sino la versión más sencilla de la entrada. Por ejemplo, «./local» se convierte en «local», «local/../bin» se convierte en «bin» y «/local/usr/../bin» se convierte en «/local/bin».
Véanse también absolutePath() y canonicalPath().
qsizetype QDir::count() const
Devuelve el número total de directorios y archivos que hay en el directorio.
Equivalente a entryList().count().
Nota: En las versiones de Qt anteriores a la 6.5, esta función devolvía « uint », no « qsizetype ».
Véase también operator[]() y entryList().
[static] QDir QDir::current()
Devuelve el directorio actual de la aplicación.
El directorio se construye utilizando la ruta absoluta del directorio actual, lo que garantiza que su path() sea igual que su absolutePath().
Véanse también currentPath(), setCurrent(), home(), root() y temp().
[static] QString QDir::currentPath()
Devuelve la ruta absoluta del directorio actual de la aplicación. El directorio actual es el último directorio establecido con QDir::setCurrent() o, si nunca se ha llamado a esta función, el directorio desde el que el proceso padre inició esta aplicación.
Véase también current(), setCurrent(), homePath(), rootPath(), tempPath() y QCoreApplication::applicationDirPath().
QString QDir::dirName() const
Devuelve el nombre del directorio; esto no es lo mismo que la ruta; por ejemplo, un directorio con el nombre «mail» podría tener la ruta «/var/spool/mail». Si el directorio no tiene nombre (por ejemplo, si se trata del directorio raíz), se devuelve una cadena vacía.
No se comprueba si realmente existe un directorio con este nombre; pero véase exists().
Véase también path(), filePath(), absolutePath() y absoluteFilePath().
[static] QFileInfoList QDir::drives()
Devuelve una lista de los directorios raíz de este sistema.
En Windows, devuelve una lista de objetos ` QFileInfo ` que contienen «C:/», «D:/», etc. No devuelve unidades con soportes extraíbles que estén vacías. En otros sistemas operativos, devuelve una lista que contiene solo un directorio raíz (es decir, «/»).
Véase también root() y rootPath().
QFileInfoList QDir::entryInfoList(const QStringList &nameFilters, QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const
Devuelve una lista de objetos ` QFileInfo ` para todos los archivos y directorios del directorio, ordenados según los filtros de nombre y atributos establecidos previamente con ` setNameFilters()` y ` setFilter()`, y clasificados según los indicadores establecidos con ` setSorting()`.
El filtro de nombre, el filtro de atributos de archivo y la especificación de ordenación pueden anularse utilizando los argumentos ` nameFilters`, ` filters` y ` sort `.
Devuelve una lista vacía si el directorio no se puede leer, no existe o si ninguna entrada cumple la especificación.
En el caso de directorios de gran tamaño, esta función puede provocar un pico de memoria, ya que crea una instancia de ` QFileInfo ` por cada entrada del directorio. Se recomienda utilizar ` QDirListing ` si el objetivo es recorrer los elementos uno por uno.
Véanse también entryList(), setNameFilters(), setSorting(), setFilter(), isReadable() y exists().
QFileInfoList QDir::entryInfoList(QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const
Devuelve una lista de objetos ` QFileInfo ` para todos los archivos y directorios del directorio, ordenados según los filtros de nombre y atributos establecidos previamente con ` setNameFilters()` y ` setFilter()`, y clasificados según los indicadores establecidos con ` setSorting()`.
El filtro de atributos y las especificaciones de ordenación pueden anularse utilizando los argumentos filters y sort.
Devuelve una lista vacía si el directorio es ilegible, no existe o si ninguna entrada cumple con las especificaciones.
En el caso de directorios grandes, esta función puede provocar un pico de memoria, ya que crea una instancia de « QFileInfo » por cada entrada del directorio. Considera la posibilidad de utilizar « QDirListing » si el objetivo es recorrer los elementos uno por uno.
Esta es una función sobrecargada.
Véanse también entryList(), setNameFilters(), setSorting(), setFilter(), isReadable() y exists().
QStringList QDir::entryList(const QStringList &nameFilters, QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const
Devuelve una lista con los nombres de todos los archivos y directorios del directorio, ordenados según los filtros de nombre y atributos establecidos previamente con setNameFilters() y setFilter(), y clasificados según los indicadores establecidos con setSorting().
El filtro de nombres, el filtro de atributos de archivo y la especificación de ordenación se pueden anular utilizando los argumentos ` nameFilters`, ` filters` y ` sort `.
Devuelve una lista vacía si el directorio no se puede leer, no existe o si ninguna entrada cumple la especificación.
En el caso de directorios de gran tamaño, esta función puede provocar un pico de memoria, ya que crea una instancia de ` QString ` por cada entrada del directorio. Se recomienda utilizar ` QDirListing ` si el objetivo es recorrer los elementos uno por uno.
Véase también entryInfoList(), setNameFilters(), setSorting() y setFilter().
QStringList QDir::entryList(QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const
Devuelve una lista con los nombres de todos los archivos y directorios del directorio, ordenados según los filtros de nombre y atributos establecidos previamente con setNameFilters() y setFilter(), y clasificados según los indicadores establecidos con setSorting().
El filtro de atributos y las especificaciones de ordenación pueden anularse utilizando los argumentos ` filters ` y ` sort `.
Devuelve una lista vacía si el directorio es ilegible, no existe o si nada se ajusta a la especificación.
Nota: Para enumerar enlaces simbólicos que apuntan a archivos inexistentes, se debe pasar ` System ` al filtro.
En directorios de gran tamaño, esta función puede provocar un pico de memoria, ya que crea una instancia de ` QString ` por cada entrada del directorio. Considera la posibilidad de utilizar ` QDirListing ` si el objetivo es recorrer los elementos uno por uno.
Esta es una función sobrecargada.
Véase también entryInfoList(), setNameFilters(), setSorting() y setFilter().
bool QDir::exists(const QString &name) const
Devuelve « true » si existe el archivo denominado « name »; en caso contrario, devuelve «false».
A menos que name contenga una ruta absoluta al archivo, se supone que el nombre del archivo es relativo al propio directorio, por lo que esta función se utiliza normalmente para comprobar la presencia de archivos dentro de un directorio.
Véase también QFileInfo::exists() y QFile::exists().
bool QDir::exists() const
Devuelve « true » si el directorio existe; en caso contrario, devuelve « false ». (Si se encuentra un archivo con el mismo nombre, esta función devolverá «false»).
La sobrecarga de esta función que admite un argumento se utiliza para comprobar la presencia de archivos y directorios dentro de un directorio.
Esta es una función sobrecargada.
Véase también QFileInfo::exists() y QFile::exists().
QString QDir::filePath(const QString &fileName) const
Devuelve la ruta de un archivo en el directorio. No comprueba si el archivo existe realmente en el directorio; sin embargo, véase exists(). Si la QDir es relativa, la ruta devuelta también será relativa. No se eliminan los separadores múltiples redundantes ni los directorios «.» y «..» en fileName (véase cleanPath()).
Véase también dirName(), absoluteFilePath(), isRelative() y canonicalPath().
[since 6.0] std::filesystem::path QDir::filesystemAbsolutePath() const
Devuelve ` absolutePath()` como ` std::filesystem::path`.
Esta función se introdujo en Qt 6.0.
Véase también absolutePath().
[since 6.0] std::filesystem::path QDir::filesystemCanonicalPath() const
Devuelve ` canonicalPath()` como ` std::filesystem::path`.
Esta función se introdujo en Qt 6.0.
Véase también canonicalPath().
[since 6.0] std::filesystem::path QDir::filesystemPath() const
Devuelve ` path()` como ` std::filesystem::path`.
Esta función se introdujo en Qt 6.0.
Véase también path().
QDir::Filters QDir::filter() const
Devuelve el valor establecido mediante la función ` setFilter()`
Véase también setFilter().
[static] QString QDir::fromNativeSeparators(const QString &pathName)
Devuelve pathName utilizando «/» como separador de carpetas. En Windows, por ejemplo, fromNativeSeparators("c:\\winnt\\system32") devuelve «c:/winnt/system32».
La cadena devuelta puede ser igual que el argumento en algunos sistemas operativos, por ejemplo, en Unix.
Véase también toNativeSeparators() y separator().
[static] QDir QDir::home()
Devuelve el directorio de inicio del usuario.
El directorio se construye utilizando la ruta absoluta del directorio de inicio, lo que garantiza que su función « path()» sea igual que su « absolutePath()».
Consulte homePath() para obtener más detalles.
Véanse también las funciones drives(), current(), root() y temp().
[static] QString QDir::homePath()
Devuelve la ruta absoluta del directorio de inicio del usuario.
En Windows, esta función devolverá el directorio del perfil del usuario actual. Normalmente, es:
C:/Users/UsernameUtiliza la función toNativeSeparators() para convertir los separadores a los adecuados para el sistema operativo subyacente.
Si el directorio del perfil del usuario actual no existe o no se puede recuperar, se comprobarán las siguientes alternativas (en el orden indicado) hasta que se encuentre una ruta existente y disponible:
- La ruta especificada por la variable de entorno `
USERPROFILE`. - La ruta formada al concatenar las variables de entorno
HOMEDRIVEyHOMEPATH. - La ruta especificada por la variable de entorno `
HOME`. - La ruta devuelta por la función rootPath() (que utiliza la variable de entorno
SystemDrive). - El directorio
C:/.
En sistemas operativos distintos de Windows, se utiliza la variable de entorno ` HOME ` si existe; de lo contrario, se utiliza la ruta devuelta por la función ` rootPath()`.
Véanse también home(), currentPath(), rootPath() y tempPath().
bool QDir::isAbsolute() const
Devuelve ` true ` si la ruta del directorio es absoluta; en caso contrario, devuelve ` false`. Véase ` isAbsolutePath()` ().
Nota: Las rutas que comienzan con dos puntos (:) siempre se consideran absolutas, ya que indican una ruta QResource.
Véanse también isRelative(), makeAbsolute() y cleanPath().
[static] bool QDir::isAbsolutePath(const QString &path)
Devuelve « true » si « path » es una ruta absoluta; devuelve « false » si es una ruta relativa.
Nota: Las rutas que comienzan con dos puntos (:) siempre se consideran absolutas, ya que denotan un QResource.
Véase también isAbsolute(), isRelativePath(), makeAbsolute(), cleanPath() y QResource.
bool QDir::isEmpty(QDir::Filters filters = Filters(AllEntries | NoDotAndDotDot)) const
Devuelve si el directorio está vacío.
Equivalente a ` count() == 0 ` con los filtros ` QDir::AllEntries | QDir::NoDotAndDotDot`, pero más rápido, ya que solo comprueba si el directorio contiene al menos una entrada.
Nota: A menos que se configuren los indicadores de ` filters ` para incluir ` QDir::NoDotAndDotDot ` (como hace el valor por defecto), ningún directorio está vacío.
Véase también count(), entryList() y setFilter().
bool QDir::isReadable() const
Devuelve ` true ` si el directorio es legible y podemos abrir los archivos por su nombre; en caso contrario, devuelve ` false`.
Advertencia: Un valor falso devuelto por esta función no garantiza que no se pueda acceder a los archivos del directorio.
Véase también QFileInfo::isReadable().
bool QDir::isRelative() const
Devuelve « true » si la ruta del directorio es relativa; en caso contrario, devuelve «false». (En Unix, una ruta es relativa si no empieza por «/»).
Nota: Las rutas que comienzan con dos puntos (:) siempre se consideran absolutas, ya que indican un QResource.
Véase también makeAbsolute(), isAbsolute(), isAbsolutePath() y cleanPath().
[static] bool QDir::isRelativePath(const QString &path)
Devuelve « true » si « path » es una ruta relativa; devuelve « false » si es una ruta absoluta.
Nota: Las rutas que comienzan con dos puntos (:) siempre se consideran absolutas, ya que denotan un QResource.
Véase también isRelative(), isAbsolutePath() y makeAbsolute().
bool QDir::isRoot() const
Devuelve « true » si el directorio es el directorio raíz; en caso contrario, devuelve « false ».
Nota: Si el directorio es un enlace simbólico al directorio raíz, esta función devuelve ` false`. Si quieres comprobarlo, utiliza ` canonicalPath()`, p. ej.:
QDir dir("/tmp/root_link");
dir = dir.canonicalPath();
if (dir.isRoot())
qWarning("It is a root link");Véase también root() y rootPath().
[static constexpr noexcept] QChar QDir::listSeparator()
Devuelve el separador nativo de la lista de rutas: «:» en Unix y «;» en Windows.
Véase también separator().
bool QDir::makeAbsolute()
Convierte la ruta del directorio en una ruta absoluta. Si ya es absoluta, no ocurre nada. Devuelve « true » si la conversión se ha realizado correctamente; en caso contrario, devuelve « false ».
Véanse también isAbsolute(), isAbsolutePath(), isRelative() y cleanPath().
[static] bool QDir::match(const QString &filter, const QString &fileName)
Devuelve « true » si « fileName » coincide con el patrón comodín (glob) « filter »; en caso contrario, devuelve « false ». « filter » puede contener varios patrones separados por espacios o punto y coma. La coincidencia no distingue entre mayúsculas y minúsculas.
Véase también QRegularExpression::fromWildcard(), entryList() y entryInfoList().
[static] bool QDir::match(const QStringList &filters, const QString &fileName)
Devuelve « true » si « fileName » coincide con cualquiera de los patrones comodín (glob) de la lista de « filters »; en caso contrario, devuelve « false ». La coincidencia no distingue entre mayúsculas y minúsculas.
Esta es una función sobrecargada.
Véanse también QRegularExpression::fromWildcard(), entryList() y entryInfoList().
bool QDir::mkdir(const QString &dirName, std::optional<QFileDevice::Permissions> permissions = std::nullopt) const
Crea un subdirectorio llamado « dirName » con el contenido especificado en « permissions ».
Si permissions es std::nullopt (el valor por defecto), esta función establecerá los permisos predeterminados.
Devuelve true si la operación se realiza con éxito; devuelve false si la operación falla o si dirName ya existía.
Si dirName ya existía, este método no modificará sus permisos.
En sistemas POSIX, los archivos « permissions » se modifican mediante la umask (máscara de creación de archivos) del proceso actual, lo que significa que algunos bits de permiso podrían estar desactivados.
En Windows, por defecto, un nuevo directorio hereda sus permisos del directorio padre. Los permissions se emulan mediante ACL. Estas ACL pueden estar en un orden no canónico cuando al grupo se le conceden menos permisos que a otros. Los archivos y directorios con dichos permisos generarán advertencias al abrir la pestaña «Seguridad» del cuadro de diálogo «Propiedades». Conceder al grupo todos los permisos otorgados a «Otros» evita dichas advertencias.
Nota: En Qt 6.10 se añadió el parámetro « permissions ». Para recuperar el comportamiento anterior (utilizando los permisos predeterminados específicos de la plataforma) de « mkdir(const QString &) », establezca « permissions » en « std::nullopt » (el valor predeterminado). Este nuevo método también sustituye de forma transparente la sobrecarga de « mkdir(const QString &, QFile::Permissions) ».
Véase también ` rmdir()`, ` mkpath()` y ` rmpath()`.
bool QDir::mkpath(const QString &dirPath, std::optional<QFileDevice::Permissions> permissions = std::nullopt) const
Crea un directorio llamado « dirPath ».
Si « dirPath » aún no existe, este método lo creará —junto con cualquier directorio padre que no exista— con « permissions ».
Si « dirPath » ya existía, este método no modificará sus permisos; lo mismo ocurre con cualquier directorio padre ya existente.
Si permissions es std::nullopt (el valor por defecto), esta función establecerá los permisos por defecto.
Devuelve true si la operación se realiza correctamente o si dirPath ya existía; en caso contrario, devuelve false.
En sistemas POSIX, permissions se modifican según la umask (máscara de creación de archivos) del proceso actual, lo que significa que algunos bits de permiso podrían estar desactivados.
En Windows, por defecto, un nuevo directorio hereda sus permisos del directorio padre. permissions se emulan mediante ACL. Estas ACL pueden estar en un orden no canónico cuando al grupo se le conceden menos permisos que a otros. Los archivos y directorios con dichos permisos generarán advertencias al abrir la pestaña «Seguridad» del cuadro de diálogo «Propiedades». Conceder al grupo todos los permisos otorgados a «otros» evita dichas advertencias.
Nota: En Qt 6.10 se añadió el parámetro « permissions ». Para recuperar el comportamiento anterior (utilizando los permisos predeterminados específicos de la plataforma) de « mkpath(const QString &) », establezca « permissions » en « std::nullopt » (el valor predeterminado).
Véase también rmpath(), mkdir() y rmdir().
QStringList QDir::nameFilters() const
Devuelve la lista de cadenas establecida mediante setNameFilters()
Véase también ` setNameFilters()`.
QString QDir::path() const
Devuelve la ruta. Esta puede contener enlaces simbólicos, pero nunca contiene caracteres redundantes como «.», «..» ni separadores múltiples.
La ruta devuelta puede ser absoluta o relativa (véase setPath()).
Véanse también setPath(), absolutePath(), exists(), cleanPath(), dirName(), absoluteFilePath(), toNativeSeparators() y makeAbsolute().
void QDir::refresh() const
Actualiza la información del directorio.
QString QDir::relativeFilePath(const QString &fileName) const
Devuelve la ruta a fileName relativa al directorio.
QDir dir("/home/bob");
QString s;
s = dir.relativeFilePath("images/file.jpg"); // s is "images/file.jpg"
s = dir.relativeFilePath("/home/mary/file.txt"); // s is "../mary/file.txt"Véase también absoluteFilePath(), filePath() y canonicalPath().
bool QDir::remove(const QString &fileName)
Elimina el archivo « fileName ».
Devuelve « true » si el archivo se ha eliminado correctamente; en caso contrario, devuelve « false ».
bool QDir::removeRecursively()
Elimina el directorio, incluido todo su contenido.
Devuelve « true » si se realiza correctamente; en caso contrario, devuelve «false».
Si no se puede eliminar un archivo o directorio, removeRecursively() continúa e intenta eliminar tantos archivos y subdirectorios como sea posible; a continuación, devuelve « false ».
Si el directorio ya se había eliminado, el método devuelve ` true ` (resultado esperado ya alcanzado).
Nota: Esta función está pensada para eliminar un pequeño directorio interno de la aplicación (como un directorio temporal), pero no para directorios visibles para el usuario. Para operaciones visibles para el usuario, se recomienda más bien informar de los errores de forma más precisa al usuario, ofrecer soluciones en caso de error, mostrar el progreso durante la eliminación, ya que podría tardar varios minutos, etc.
bool QDir::rename(const QString &oldName, const QString &newName)
Cambia el nombre de un archivo o directorio de « oldName » a « newName » y devuelve «true» si la operación se realiza correctamente; en caso contrario, devuelve « false ».
En la mayoría de los sistemas de archivos, rename() solo falla si oldName no existe o si ya existe un archivo con el nuevo nombre. Sin embargo, también hay otras razones por las que rename() puede fallar. Por ejemplo, al menos en un sistema de archivos, rename() falla si newName apunta a un archivo abierto.
Si oldName es un archivo (no un directorio) cuyo nombre no se puede cambiar de inmediato, Qt intentará copiar oldName a newName y eliminar oldName.
Véase también QFile::rename().
bool QDir::rmdir(const QString &dirName) const
Elimina el directorio especificado por ` dirName`.
El directorio debe estar vacío para que rmdir() se ejecute correctamente.
Devuelve true si se ejecuta correctamente; en caso contrario, devuelve false.
Véase también mkdir().
bool QDir::rmpath(const QString &dirPath) const
Elimina la ruta del directorio dirPath.
La función eliminará todos los directorios principales de dirPath, siempre que estén vacíos. Esto es lo contrario de mkpath(dirPath).
Devuelve true si se ejecuta correctamente; en caso contrario, devuelve false.
Véase también mkpath().
[static] QDir QDir::root()
Devuelve el directorio raíz.
El directorio se construye utilizando la ruta absoluta del directorio raíz, lo que garantiza que su función ` path()` será la misma que su función ` absolutePath()`.
Consulta rootPath() para obtener más detalles.
Véanse también drives(), current(), home() y temp().
[static] QString QDir::rootPath()
Devuelve la ruta absoluta del directorio raíz.
En los sistemas operativos Unix, devuelve «/». En los sistemas de archivos de Windows, normalmente devuelve «c:/».
Véanse también root(), drives(), currentPath(), homePath() y tempPath().
[static] QStringList QDir::searchPaths(const QString &prefix)
Devuelve las rutas de búsqueda para prefix.
Véase también setSearchPaths() y addSearchPath().
[static] QChar QDir::separator()
Devuelve el separador de directorios nativo: «/» en Unix y «\» en Windows.
No es necesario utilizar esta función para construir rutas de archivo. Si siempre utilizas «/», Qt adaptará tus rutas para que se ajusten al sistema operativo subyacente. Si deseas mostrar las rutas al usuario utilizando el separador de su sistema operativo, utiliza toNativeSeparators().
Véase también listSeparator().
[static] bool QDir::setCurrent(const QString &path)
Establece el directorio de trabajo actual de la aplicación en path. Devuelve true si el cambio de directorio se ha realizado correctamente; en caso contrario, devuelve false.
QString absolute = "/local/bin";
QString relative = "local/bin";
QFileInfo absFile(absolute);
QFileInfo relFile(relative);
QDir::setCurrent(QDir::rootPath());
// absFile and relFile now point to the same file
QDir::setCurrent("/tmp");
// absFile now points to "/local/bin",
// while relFile points to "/tmp/local/bin"Véase también current(), currentPath(), home(), root() y temp().
void QDir::setFilter(QDir::Filters filters)
Establece el filtro utilizado por entryList() y entryInfoList() en filters. El filtro se utiliza para especificar el tipo de archivos que deben devolver entryList() y entryInfoList(). Véase QDir::Filter.
Véanse también filter() y setNameFilters().
void QDir::setNameFilters(const QStringList &nameFilters)
Establece los filtros de nombres utilizados por entryList() y entryInfoList() en la lista de filtros especificada por nameFilters.
Cada filtro de nombre es un filtro de comodines (globbing) que reconoce los comodines de * y ?. Véase QRegularExpression::fromWildcard().
Por ejemplo, el siguiente código establece tres filtros de nombre en un QDir para garantizar que solo se muestren los archivos con extensiones que se suelen utilizar para los archivos fuente de C++:
QStringList filters;
filters << "*.cpp" << "*.cxx" << "*.cc";
dir.setNameFilters(filters);Véase también nameFilters() y setFilter().
void QDir::setPath(const QString &path)
Establece la ruta del directorio en path. La ruta se limpia de caracteres redundantes «.», «..» y de separadores múltiples. No se comprueba si realmente existe un directorio con esta ruta; pero puedes comprobarlo tú mismo utilizando exists().
La ruta puede ser absoluta o relativa. Las rutas absolutas comienzan con el separador de directorios «/» (opcionalmente precedido por una especificación de unidad en Windows). Los nombres de archivo relativos comienzan con un nombre de directorio o un nombre de archivo y especifican una ruta relativa al directorio actual. Un ejemplo de ruta absoluta es la cadena «/tmp/quartz», mientras que una ruta relativa podría ser «src/fatlib».
Véase también path(), absolutePath(), exists(), cleanPath(), dirName(), absoluteFilePath(), isRelative() y makeAbsolute().
[since 6.0] void QDir::setPath(const std::filesystem::path &path)
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.0.
[static] void QDir::setSearchPaths(const QString &prefix, const QStringList &searchPaths)
Establece o sustituye las rutas de búsqueda de Qt para los nombres de archivo con el prefijo « prefix » por « searchPaths ».
Para especificar un prefijo para un nombre de archivo, antepón el prefijo seguido de dos puntos (por ejemplo, «images:undo.png», «xmldocs:books.xml»). prefix solo puede contener letras o números (por ejemplo, no puede contener dos puntos ni una barra).
Qt utiliza esta ruta de búsqueda para localizar archivos con un prefijo conocido. Las entradas de la ruta de búsqueda se comprueban en orden, empezando por la primera entrada.
QDir::setSearchPaths("icons", QStringList(QDir::homePath() + "/images"));
QDir::setSearchPaths("docs", QStringList(":/embeddedDocuments"));
//...
QPixmap pixmap("icons:undo.png"); // will look for undo.png in QDir::homePath() + "/images"
QFile file("docs:design.odf"); // will look in the :/embeddedDocuments resource pathEl prefijo del nombre de archivo debe tener una longitud mínima de 2 caracteres para evitar conflictos con las letras de unidad de Windows.
Las rutas de búsqueda pueden contener rutas al sistema de recursos de Qt.
Véase también searchPaths().
void QDir::setSorting(QDir::SortFlags sort)
Establece el orden de clasificación que utilizan las funciones ` entryList()` y ` entryInfoList()`.
La orden de clasificación ` sort ` se especifica mediante la operación OR de los valores de la enumeración ` QDir::SortFlag`.
Véanse también sorting() y SortFlag.
QDir::SortFlags QDir::sorting() const
Devuelve el valor establecido mediante setSorting()
Véase también setSorting() y SortFlag.
[noexcept] void QDir::swap(QDir &other)
Sustituye esta instancia de QDir por other. Esta operación es muy rápida y nunca falla.
[static] QDir QDir::temp()
Devuelve el directorio temporal del sistema.
El directorio se construye utilizando la ruta canónica absoluta del directorio temporal, lo que garantiza que su path() sea igual que su absolutePath().
Consulta tempPath() para obtener más detalles.
Véanse también drives(), current(), home() y root().
[static] QString QDir::tempPath()
Devuelve la ruta canónica absoluta del directorio temporal del sistema.
En sistemas Unix/Linux, se trata de la ruta contenida en la variable de entorno TMPDIR o en /tmp si no está definida TMPDIR. En Windows, suele ser la ruta contenida en la variable de entorno TEMP o TMP. La ruta devuelta por este método no termina con un separador de directorios, a menos que se trate del directorio raíz (de una unidad).
Véase también temp(), currentPath(), homePath() y rootPath().
[static] QString QDir::toNativeSeparators(const QString &pathName)
Devuelve « pathName » con los separadores «/» convertidos a separadores adecuados para el sistema operativo subyacente.
En Windows, toNativeSeparators("c:/winnt/system32") devuelve "c:\winnt\system32 ".
La cadena devuelta puede ser igual que el argumento en algunos sistemas operativos, por ejemplo, en Unix.
Véanse también fromNativeSeparators() y separator().
[noexcept] QDir &QDir::operator=(QDir &&other)
Asigna « other » a esta instancia de « QDir ». .
QDir &QDir::operator=(const QDir &dir)
Crea una copia del objeto « dir » y la asigna a este objeto « QDir ».
QString QDir::operator[](qsizetype pos) const
Devuelve el nombre del archivo en la posición pos de la lista de nombres de archivos. Equivalente a entryList().at(index). pos debe ser una posición de índice válida en la lista (es decir, 0 <= pos < count()).
Nota: En las versiones de Qt anteriores a la 6.5, pos era un int, no un qsizetype.
Elementos relacionados no miembros
[noexcept] bool operator!=(const QDir &lhs, const QDir &rhs)
Devuelve « true » si el directorio « lhs » y el directorio « rhs » tienen rutas diferentes o configuraciones de ordenación o filtrado distintas; en caso contrario, devuelve « false ».
Ejemplo:
// El directorio actual es «/usr/local»
QDir d1("/usr/local/bin");
d1.setFilter(QDir::Executable);
QDir d2("bin");
if (d1 != d2)
qDebug("They differ");[noexcept] bool operator==(const QDir &lhs, const QDir &rhs)
Devuelve « true » si el directorio lhs y el directorio rhs tienen la misma ruta y sus ajustes de ordenación y filtrado son idénticos; en caso contrario, devuelve « false ».
Ejemplo:
© 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.