Qué es y cómo usar std::filesystem::path en C++

Un std::filesystem::path es una clase para representar rutas de archivos y directorios de forma portable entre sistemas operativos.

Si has programado en C++ antes de 2017, seguro que te has enfrentado a la pesadilla de las barras.

• En Windows, las rutas usan contrabarra: C:\Usuarios\Luis (que en código debes escapar como C:\\Usuarios\\Luis).
• En Linux y macOS, las rutas usan barra normal: /home/luis.

Antes era frecuente llenar el código de #ifdef _WIN32 o detectar el sistema operativo para elegir el separador. El resultado era más difícil de mantener y propenso a errores.

Con la llegada de C++17, esto se acabó. Tenemos una clase diseñada específicamente para abstraer el concepto de “ubicación en el disco”: std::filesystem::path.

¿Qué es fs::path?

std::filesystem::path (o fs::path si usamos el alias habitual) no es simplemente una std::string. Es un objeto inteligente que entiende la estructura de una ruta.

Sabe distinguir el nombre del archivo, la extensión, el directorio padre y la unidad de disco. Y lo más importante: gestiona los separadores automáticamente.

#include <iostream>
#include <filesystem>

namespace fs = std::filesystem;

int main() {
    // Definimos una ruta de forma genérica (usando / funciona en todos los SO modernos)
    fs::path ruta = "datos/config/usuario.ini";

    std::cout << "Ruta detectada: " << ruta << "\n";
}

Componer rutas con el operador /

Esta es, posiblemente, mi característica favorita. Ya no tienes que concatenar strings preocupándote de si te falta una barra al final o no.

La clase path sobrecarga el operador división (/) para unir carpetas.

fs::path carpeta = "proyecto";
fs::path subcarpeta = "assets";
fs::path archivo = "textura.png";

// Une las rutas añadiendo el separador correcto automáticamente
fs::path rutaCompleta = carpeta / subcarpeta / archivo;

// En Windows saldrá: "proyecto\assets\textura.png"
// En Linux saldrá: "proyecto/assets/textura.png"
std::cout << rutaCompleta << "\n";

Esto hace que el código quede más limpio y legible.

Descomponiendo rutas

A menudo recibimos una ruta completa (ej: C:/fotos/vacaciones.jpg) y necesitamos extraer solo una parte. fs::path tiene métodos para diseccionar la ruta quirúrgicamente.

Supongamos la ruta: C:/carpeta/archivo.txt

Cambiar la extensión

Imagina que quieres convertir un montón de imágenes .png a .jpg. Necesitas generar el nuevo nombre de archivo.

fs::path origen = "foto.png";

// Creamos una copia y reemplazamos la extensión
fs::path destino = origen;
destino.replace_extension(".jpg");

std::cout << "Origen: " << origen << "\n";  // foto.png
std::cout << "Destino: " << destino << "\n"; // foto.jpg

Conversión entre path y cadenas

Aunque fs::path se parece a un string, a veces necesitamos un std::string real (por ejemplo, para pasarlo a una librería antigua que no soporte C++17 o para imprimirlo en logs específicos).

El objeto path almacena la ruta en un formato nativo del sistema (que puede ser wchar_t en Windows).

• .string(): Devuelve std::string (Cuidado con caracteres especiales en Windows).
• .u8string(): Devuelve una cadena UTF-8; desde C++20 su tipo es std::u8string.
• .c_str(): Devuelve un puntero C (const char* o const wchar_t*).

fs::path ruta = "tildes/año.txt";

// Para usar con fstream (fstream acepta path directamente, pero bueno saberlo)
std::ifstream file(ruta); 

// Para imprimir o guardar en base de datos
std::string rutaTexto = ruta.string();

Iterar sobre una ruta

Curiosamente, fs::path también actúa como un contenedor. Si iteramos sobre él, obtenemos cada uno de los componentes de la ruta.

fs::path ruta = "/usr/local/bin/gcc";

for (const auto& parte : ruta) {
    std::cout << parte << "\n";
}

Salida:

/
usr
local
bin
gcc