Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Unir rutas con `/` en `std::filesystem`

El operador `/` devuelve una ruta nueva sin modificar los operandos. La sintaxis de la ruta derecha determina si se añade a la izquierda o si la sustituye en parte o por completo.

Versión: ISO C++23; implementation support may vary

Sintaxis

#include <filesystem>

// Friend declaration inside std::filesystem::path (not a member):
friend path operator/(const path& lhs, const path& rhs);

// Typical use, with base of type std::filesystem::path:
base / "guide.txt"

En <filesystem>, la etiqueta std::filesystem::operator/ designa un operador que une rutas, no una división ni una función miembro. Disponible desde C++17, es una función amiga no miembro del espacio de nombres std::filesystem. Se encuentra mediante la búsqueda dependiente de los argumentos (ADL), no mediante la búsqueda cualificada. Escribe base / "guide.txt" con base de tipo path: el literal se convierte a path. Dos literales de cadena por sí solos no funcionan con /.

lhs / rhs aplica /= a una copia de lhs y devuelve un path por valor. El operador miembro /= modifica el operando izquierdo y devuelve una referencia a este; += concatena el texto de la ruta en su formato nativo sin insertar un separador. Si rhs es absoluta o tiene un nombre de raíz distinto del de lhs, sustituye toda la ruta izquierda. Si no, un directorio raíz en rhs elimina el directorio raíz y la parte relativa de la izquierda, pero conserva su nombre de raíz. Después se añade la ruta derecha sin su nombre de raíz, con el separador preferido donde lo exijan las reglas. Incluso un operando derecho vacío puede añadir un separador final.

La unión no normaliza la ruta. p.lexically_normal() devuelve una ruta nueva que elimina componentes . redundantes y simplifica pares como drafts/... p.lexically_relative(base) calcula el recorrido de base a p sin normalizar antes las rutas. En las comprobaciones iniciales devuelve una ruta vacía, por ejemplo si los nombres de raíz son distintos o si algún nombre de archivo en la parte relativa de cualquiera de las dos rutas puede interpretarse como nombre de raíz. Si las rutas superan esas comprobaciones y sus secuencias de componentes son idénticas, devuelve ..

p.is_absolute() comprueba si la ruta es absoluta según las reglas de la plataforma: / por sí sola es absoluta en POSIX, pero no en Windows. p.empty() comprueba si la ruta en formato genérico está vacía, no si un directorio está vacío. p.begin() apunta al primer componente, no a un carácter ni a una entrada de directorio; para una ruta vacía devuelve p.end(). No uses los iteradores después de destruir p ni tras llamar a una función miembro no const sobre p. p.generic_string() devuelve un std::string con separadores /, sin garantizar UTF-8.

Estas operaciones trabajan con la sintaxis de la ruta: no comprueban la existencia de archivos ni resuelven enlaces simbólicos. La unión puede lanzar una excepción, por ejemplo std::bad_alloc. Ni / ni lexically_normal() garantizan que una ruta no fiable quede dentro de un directorio elegido: las raíces, .. o los enlaces simbólicos pueden invalidar esa suposición.

Ejemplos

#include <filesystem>
#include <iostream>

namespace fs = std::filesystem;

int main() {
    const fs::path base{"docs"};
    const fs::path joined = base / "./drafts/../guide.txt";
    const fs::path normal = joined.lexically_normal();
    const fs::path relative = normal.lexically_relative(base);

    std::cout << "base: " << base.generic_string() << '\n'
              << "joined: " << joined.generic_string() << '\n'
              << "normal: " << normal.generic_string() << '\n'
              << "relative: " << relative.generic_string() << '\n'
              << "first: " << normal.begin()->generic_string() << '\n'
              << std::boolalpha
              << "absolute: " << normal.is_absolute() << '\n'
              << "relative.empty(): " << relative.empty() << '\n';
}

Resultado

base: docs
joined: docs/./drafts/../guide.txt
normal: docs/guide.txt
relative: guide.txt
first: docs
absolute: false
relative.empty(): false

El ejemplo muestra que `base` no cambia. La ruta unida aún contiene `.` y `..`; la normalización los elimina. El recorrido de `docs` a la ruta normalizada es `guide.txt`.

Lecciones relacionadas

  • C++ · Lección 48 · Avanzado · Versión: 3

Fuentes