CKTIS / C++
Juntar caminhos com `/` em `std::filesystem`
O operador `/` devolve um novo caminho sem alterar os operandos. A sintaxe do caminho à direita determina se este é acrescentado ao da esquerda ou se o substitui total ou parcialmente.
Versão: ISO C++23; implementation support may vary
Sintaxe
#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"Em <filesystem>, a designação std::filesystem::operator/ refere-se a um operador que junta caminhos, não a uma divisão nem a uma função membro. Disponível desde C++17, é uma função amiga não membro no espaço de nomes std::filesystem. É encontrada pela pesquisa dependente dos argumentos (ADL), não pela pesquisa qualificada. Escreve base / "guide.txt" com base do tipo path: o literal é convertido em path. Dois literais de cadeia de caracteres, por si só, não funcionam com /.
lhs / rhs aplica /= a uma cópia de lhs e devolve um path por valor. O operador membro /= altera o operando esquerdo e devolve uma referência para esse operando. Já += concatena o texto do caminho nativo sem introduzir um separador. Se rhs for absoluto ou tiver um nome de raiz diferente do de lhs, substitui todo o caminho da esquerda. Caso contrário, um diretório raiz em rhs elimina o diretório raiz e a parte relativa da esquerda, mas preserva o nome da raiz. Acrescenta-se então o caminho direito sem o respetivo nome de raiz, com o separador preferido onde as regras o exigirem. Mesmo um operando direito vazio pode acrescentar um separador final.
A junção não normaliza o caminho. p.lexically_normal() devolve um novo caminho, eliminando componentes . redundantes e simplificando pares como drafts/... p.lexically_relative(base) calcula o percurso de base até p sem normalizar primeiro os caminhos. Nas verificações iniciais, devolve um caminho vazio, por exemplo se os nomes de raiz forem diferentes ou se algum nome de ficheiro na parte relativa de qualquer dos caminhos puder ser interpretado como um nome de raiz. Se os caminhos passarem essas verificações e as sequências de componentes forem idênticas, devolve ..
p.is_absolute() verifica se o caminho é absoluto de acordo com as regras da plataforma: / por si só é absoluto em POSIX, mas não em Windows. p.empty() verifica se o caminho em formato genérico está vazio, não se um diretório está vazio. p.begin() aponta para o primeiro componente, não para um carácter nem para uma entrada de diretório; num caminho vazio devolve p.end(). Não uses os iteradores depois de p ser destruído nem depois de chamares uma função membro não const em p. p.generic_string() devolve uma std::string com separadores /, sem garantir UTF-8.
Estas operações tratam da sintaxe dos caminhos: não verificam se os ficheiros existem nem resolvem ligações simbólicas. A junção pode lançar uma exceção, por exemplo std::bad_alloc. Nem / nem lexically_normal() garantem que um caminho não fiável fica dentro do diretório escolhido: raízes, .. ou ligações simbólicas podem invalidar essa suposição.
Exemplos
#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
O exemplo mostra que `base` não se altera. O caminho resultante da junção ainda contém `.` e `..`; a normalização remove-os. O percurso de `docs` até ao caminho normalizado é `guide.txt`.
Lições relacionadas
- C++ · Lição 48 · Avançado · Versão: 3
Fontes
- C++ working draft: path non-member functions [fs.path.nonmember]
- C++ working draft: hidden friends [hidden.friends]
- C++ working draft: argument-dependent name lookup [basic.lookup.argdep]
- C++ working draft: path appends [fs.path.append]
- C++ working draft: path concatenation [fs.path.concat]
- C++ working draft: path generation [fs.path.gen]
- C++ working draft: path queries [fs.path.query]
- C++ working draft: path iterators [fs.path.itr]
- C++ working draft: generic pathname format [fs.path.generic]
- C++ working draft: filesystem error reporting [fs.err.report]
- cppreference: std::filesystem::operator/(std::filesystem::path)
- cppreference: std::filesystem::path::generic_string and related observers