`path` classe

A path classe armazena um objeto do tipo string_type, chamado myname aqui para fins de exposição, adequado para uso como nome de caminho. string_typeé sinónimo de basic_string<value_type>, onde value_type é sinónimo de wchar_t no Windows ou char no POSIX.

A path classe descrita aqui é a classe C++17 std::filesystem::path no <filesystem> cabeçalho.

Para mais informações e exemplos de código, veja Navegação do Sistema de Ficheiros (C++).

Sintaxe

class path;

Constructors

Construtor	Descrição
`path`	Constrói um `path`.

Typedefs (definições de tipos)

Nome do tipo	Descrição
`const_iterator`	Um sinónimo de `iterator`.
`iterator`	Um iterador constante bidirecional que designa os `path` componentes de `myname`.
`string_type`	O tipo é sinônimo de `basic_string<value_type>`.

Enumerations

Nome do tipo	Descrição
`format`	Especifica o formato do nome de caminho para construtores: `auto_format`, `native_format`, ou `generic_format`.

Funções de membro

Função de membro	Descrição
`append`	Acrescenta a sequência especificada a `myname`, convertido e inserindo um preferred_separator conforme necessário.
`assign`	Substitui `myname` pela sequência especificada, convertida conforme necessário.
`begin`	Devolve um `path::iterator` que designa o primeiro elemento de caminho no nome do caminho, se presente.
`c_str`	Devolve um ponteiro para o primeiro carácter em `myname`.
`clear`	Executa `myname.clear()`.
`compare`	Devolve valores de comparação.
`concat`	Adiciona a sequência especificada a `myname`, convertido (mas sem inserir um separador) conforme necessário.
`empty`	Retorna `myname.empty()`.
`end`	Devolve um iterador de fim de sequência do tipo `iterator`.
`extension`	Devolve o sufixo de `filename()`.
`filename`	Devolve o componente de nome de ficheiro de `myname`, especificamente `empty() ? path() : *--end()`. O componente pode estar vazio.
`generic_string`	Devolve `this->string<Elem, Traits, Alloc>(al)` (no Windows) qualquer barra inversa convertida numa barra para a frente.
`generic_u16string`	Devolve `u16string()` (no Windows) qualquer barra inversa convertida numa barra para a frente.
`generic_u32string`	Devolve `u32string()` (no Windows) qualquer barra inversa convertida numa barra para a frente.
`generic_u8string`	Devolve `u8string()` (no Windows) qualquer barra inversa convertida numa barra para a frente.
`generic_wstring`	Devolve `wstring()` (no Windows) qualquer barra inversa convertida numa barra para a frente.
`has_extension`	Retorna `!extension().empty()`.
`has_filename`	Retorna `!filename().empty()`.
`has_parent_path`	Retorna `!parent_path().empty()`.
`has_relative_path`	Retorna `!relative_path().empty()`.
`has_root_directory`	Retorna `!root_directory().empty()`.
`has_root_name`	Retorna `!root_name().empty()`.
`has_root_path`	Retorna `!root_path().empty()`.
`has_stem`	Retorna `!stem().empty()`.
`is_absolute`	Para o Windows, a função devolve `has_root_name() && has_root_directory()`. Para POSIX, a função devolve `has_root_directory()`.
`is_relative`	Retorna `!is_absolute()`.
`lexically_normal`	Retorna `myname` convertido para a forma normal.
`lexically_proximate`	Retorna `lexically_relative(base)`, ou `*this` se esse resultado estiver vazio.
`lexically_relative`	Retornos `myname` feitos relativos a um caminho base, usando apenas análise lexical (string).
`make_preferred`	Converte cada separador em a `preferred_separator` conforme necessário.
`native`	Devolve a representação nativa do caminho.
`parent_path`	Devolve o componente do caminho pai de `myname`.
`preferred_separator`	O objeto constante fornece o carácter preferido para separar componentes do caminho, dependendo do sistema operativo anfitrião.
`relative_path`	Devolve o componente de caminho relativo de `myname`.
`remove_filename`	Remove o nome do ficheiro.
`replace_extension`	Substitui a extensão de `myname`.
`replace_filename`	Substitui o nome do ficheiro.
`root_directory`	Devolve o componente de diretório raiz de `myname`.
`root_name`	Devolve o componente raiz do nome de `myname`.
`root_path`	Devolve o componente do caminho raiz de `myname`.
`stem`	Devolve o `stem` componente de `myname`.
`string`	Converte a sequência armazenada em `myname`.
`swap`	Executa `swap(myname, right.myname)`.
`u16string`	Converte a sequência armazenada em `myname` UTF-16 e devolve-a armazenada num objeto do tipo `u16string`.
`u32string`	Converte a sequência armazenada em `myname` UTF-32 e devolve-a armazenada num objeto do tipo `u32string`.
`u8string`	Converte a sequência armazenada em `myname` UTF-8 e devolve-a armazenada num objeto do tipo `u8string`.
`value_type`	O tipo descreve os elementos de caminho preferidos pelo sistema operativo anfitrião.
`wstring`	Converte a sequência armazenada para `myname` a codificação preferida pelo sistema anfitrião para uma `wchar_t` sequência e devolve-a armazenada num objeto do tipo `wstring`.

Operators

Operator	Descrição
`operator=`	Substitui os elementos do caminho por uma cópia de outro caminho.
`operator+=`	Várias `concat` expressões.
`operator/=`	Várias `append` expressões.
`operator string_type`	Retorna `myname`.

Requisitos

Cabeçalho:<filesystem>

Espaço de nomes:std::filesystem

`path::append`

Acrescenta a sequência especificada a myname, convertido e inserindo a preferred_separator conforme necessário.

template <class Source>
path& append(const Source& source);

template <class InIt>
path& append(InIt first, InIt last);

Parameters

source
Sequência especificada.

first
Início da sequência especificada.

last
Fim da sequência especificada.

`path::assign`

Substitui myname pela sequência especificada, convertida conforme necessário.

path& assign(string_type&& source);

template <class Source>
path& assign(const Source& source);

template <class InIt>
path& assign(InIt first, InIt last);

Parameters

source
Sequência especificada.

first
Início da sequência especificada.

last
Fim da sequência especificada.

`path::begin`

Devolve um path::iterator que designa o primeiro elemento de caminho no nome do caminho, se presente.

iterator begin() const;

`path::c_str`

Devolve um ponteiro para o primeiro carácter em myname.

const value_type* c_str() const noexcept;

`path::clear`

Executa myname.clear().

void clear() noexcept;

`path::compare`

A primeira função compara os elementos deste caminho com pval. As outras funções constroem um caminho a partir do seu argumento e retornam o resultado da comparação com esse caminho.

int compare(const path& pval) const noexcept;
int compare(const string_type& str) const;
int compare(basic_string_view<value_type> str) const;
int compare(const value_type *ptr) const;

Parameters

pval
Caminho para comparar.

str
Fio para comparar.

ptr
Uma dica para comparar.

`path::concat`

Adiciona a sequência especificada a myname, convertido (mas sem inserir um separador) conforme necessário.

template <class Source>
path& concat(const Source& source);

template <class InIt>
path& concat(InIt first, InIt last);

Parameters

source
Sequência especificada.

first
Início da sequência especificada.

last
Fim da sequência especificada.

`path::const_iterator`

Um sinónimo de iterator.

typedef iterator const_iterator;

`path::empty`

Retorna myname.empty().

bool empty() const noexcept;

`path::end`

Devolve um iterador de fim de sequência do tipo iterator.

iterator end() const;

`path::extension`

Devolve o sufixo de filename().

path extension() const;

Observações

Devolve o sufixo de filename() X tal que:

Se X == path(".") || X == path("..") ou se X não contiver ponto, o sufixo está vazio.

Caso contrário, o sufixo começa com (e inclui) o ponto mais à direita.

`path::filename`

Devolve o componente de nome de ficheiro de myname, especificamente empty() ? path() : *--end(). O componente pode estar vazio.

path filename() const;

`path::format`

Especifica o formato de nome de caminho usado para interpretar a sequência de caracteres passada a um path construtor.

enum format {
    auto_format,
    native_format,
    generic_format
};

Members

Recenseador	Descrição
`auto_format`	A implementação deteta automaticamente o formato. Este é o padrão para os construtores que aceitam um `format` argumento.
`native_format`	Interprete a sequência no formato nativo do nome de caminho.
`generic_format`	Interprete a sequência no formato genérico do nome de caminho.

Observações

Como o formato nativo e o genérico são intercambiáveis no Windows, a implementação da Microsoft trata os três enumeradores da mesma forma. O format parâmetro é fornecido para conformidade e portabilidade padrão. Para mais informações, consulte a especificação WG21 N4659 [fs.class.path].

`path::generic_string`

Devolve this->string<Elem, Traits, Alloc>(al) (no Windows) qualquer barra inversa convertida numa barra para a frente.

template <class Elem,
    class Traits = char_traits<Elem>,
    class Alloc = allocator<Elem>>
  basic_string<Elem, Traits, Alloc>
    generic_string(const Alloc& al = Alloc()) const;

string generic_string() const;

`path::generic_u16string`

Devolve u16string() (no Windows) qualquer barra inversa convertida numa barra para a frente.

u16string generic_u16string() const;

`path::generic_u32string`

Devolve u32string() (no Windows) qualquer barra inversa convertida numa barra para a frente.

u32string generic_u32string() const;

`path::generic_u8string`

Devolve u8string() (no Windows) qualquer barra inversa convertida numa barra para a frente.

string generic_u8string() const;

`path::generic_wstring`

Devolve wstring() (no Windows) qualquer barra inversa convertida numa barra para a frente.

wstring generic_wstring() const;

`path::has_extension`

Retorna !extension().empty().

bool has_extension() const;

`path::has_filename`

Retorna !filename().empty().

bool has_filename() const;

`path::has_parent_path`

Retorna !parent_path().empty().

bool has_parent_path() const;

`path::has_relative_path`

Retorna !relative_path().empty().

bool has_relative_path() const;

`path::has_root_directory`

Retorna !root_directory().empty().

bool has_root_directory() const;

`path::has_root_name`

Retorna !root_name().empty().

bool has_root_name() const;

`path::has_root_path`

Retorna !root_path().empty().

bool has_root_path() const;

`path::has_stem`

Retorna !stem().empty().

bool has_stem() const;

`path::is_absolute`

Para o Windows, a função devolve has_root_name() && has_root_directory(). Para POSIX, a função devolve has_root_directory().

bool is_absolute() const;

`path::is_relative`

Retorna !is_absolute().

bool is_relative() const;

`path::iterator`

Um iterador constante bidirecional que designa os componentes do caminho de myname.

class iterator
   {
   // bidirectional iterator for path
   typedef bidirectional_iterator_tag iterator_category;
   typedef path_type value_type;
   typedef ptrdiff_t difference_type;
   typedef const value_type *pointer;
   typedef const value_type& reference;
   // ...
   };

Observações

A classe descreve um iterador constante bidirecional que designa os path componentes de myname na sequência:

o nome raiz, se presente
o diretório raiz, se estiver presente
os restantes elementos de diretório do pai path, se estiverem presentes, terminando com o nome do ficheiro, se presentes

Para pval um objeto do tipo path:

path::iterator X = pval.begin() designa o primeiro path elemento no nome do caminho, se presente.
X == pval.end() é true quando X aponta logo para além do fim da sequência de componentes.
*X devolve uma cadeia que corresponde ao componente atual
++X designa o próximo componente na sequência, se presente.
--X designa o componente anterior na sequência, se presente.
Alterar myname invalida todos os iteradores que designam elementos em myname.

`path::lexically_normal`

Retorna myname convertido para a forma normal. A conversão é puramente lexical: o sistema de ficheiros não é acedido.

path lexically_normal() const;

Observações

A normalização colapsa elementos redundantes como . separadores e .. de diretórios. Por exemplo, path("a/./b/../c").lexically_normal() yields a\c no Windows. Um caminho vazio normaliza-se para um caminho vazio; um caminho que se reduz a nada normaliza-se para .. Para o algoritmo completo de normalização, consulte a especificação WG21 N4659 [fs.path.generic].

`path::lexically_proximate`

Devolve o resultado de lexically_relative(base). Se esse resultado for um caminho vazio, devolve uma cópia de em vez disso *this .

path lexically_proximate(const path& base) const;

Parameters

base
O caminho base para aproximar *this .

`path::lexically_relative`

Retornos myname feitos relativos a base, usando apenas análise lexical (de cadeias). O sistema de ficheiros não é acedido.

path lexically_relative(const path& base) const;

Parameters

base
O caminho base a fazer *this relativo a.

Observações

Se root_name() != base.root_name(), ou se um caminho for absoluto e o outro relativo, ou se o caminho tiver um nome de ficheiro mas sem diretório raiz enquanto a base não tem, retorna um caminho vazio. Caso contrário, determina o caminho relativo de base para *this encontrando o primeiro elemento desajustado e emitindo .. para cada elemento restante de base, seguido pelos elementos restantes de *this. Por exemplo, path("/a/d").lexically_relative("/a/b/c") produz ..\..\d. Para o algoritmo completo, consulte a especificação WG21 N4659 [fs.path.gen].

`path::make_preferred`

Converte cada separador em a preferred_separator conforme necessário.

path& make_preferred();

`path::native`

Obtenha a representação nativa da string do caminho.

const string_type& native() const noexcept;

Observações

O caminho está disponível num formato genérico portátil (ver generic_string()) ou no formato nativo do caminho. Esta função devolve a cadeia nativa. Num sistema POSIX, o formato genérico e o formato nativo são os mesmos.

No exemplo seguinte a correr no Windows, a cadeia de caminho genérica é c:/t/temp.txt e a cadeia nativa é c:\t\temp.txt.

// Compile with /std:c++17 or higher
#include <filesystem>

int main()
{
    std::filesystem::path p(R"(c:\t\temp.txt)");
    auto native = p.native();          // Windows: L"c:\\t\\temp.txt"
    auto generic = p.generic_string(); // Windows: "c:/t/temp.txt"
}

`path::operator=`

Substitui os elementos do caminho por uma cópia de outro caminho.

path& operator=(const path& right);
path& operator=(path&& right) noexcept;
path& operator=(string_type&& source);

template <class Source>
path& operator=(const Source& source);

Parameters

right
O path ser copiado para o path.

source
A fonte path.

Observações

O primeiro operador membro copia right.myname para myname. O segundo operador membro move-se right.myname para myname. O terceiro operador membro move-se source para myname. O quarto operador membro comporta-se da mesma forma que *this = path(source).

`path::operator+=`

Várias concat expressões.

path& operator+=(const path& right);
path& operator+=(const string_type& str);
path& operator+=(basic_string_view<value_type> str);
path& operator+=(const value_type *ptr);
path& operator+=(value_type elem);

template <class Source>
path& operator+=(const Source& source);

template <class Elem>
path& operator+=(Elem elem);

Parameters

right
O caminho adicional.

str
O fio adicional.

ptr
O ponteiro adicional.

elem
A adição value_type ou Elem.

source
A fonte adicional.

Observações

As funções membro comportam-se da mesma forma que chamar concat com o argumento. As pathsobrecargas , string_type, basic_string_view, e terminadas value_type* nulas concatenam a sequência de caracteres do argumento. As value_type sobrecargas e Elem concatenam um único carácter. A sobrecarga templated Source concatena a sequência fonte convertida.

`path::operator/=`

Várias append expressões.

path& operator/=(const path& right);

template <class Source>
path& operator/=(const Source& source);

Parameters

right
O caminho adicional.

source
A fonte adicional.

Observações

As funções membros comportam-se da mesma forma que as seguintes expressões correspondentes:

append(right);
append(source);

`path::operator string_type`

Retorna myname.

operator string_type() const;

`path::parent_path`

Devolve o componente do caminho pai de myname.

path parent_path() const;

Observações

Devolve o componente do caminho pai de myname, especificamente o prefixo de myname após a remoção filename().native() e quaisquer separadores de diretório imediatamente anteriores. (Igualmente, se begin() != end(), é a combinação de todos os elementos do intervalo [begin(), --end()) aplicando sucessivamente operator/=.) O componente pode ser vazio.

`path::path`

Constrói a path de várias formas.

path() noexcept;

path(const path& right);
path(path&& right) noexcept;

path(string_type&& source, format fmt = auto_format);

template <class Source>
path(const Source& source, format fmt = auto_format);

template <class InIt>
path(InIt first, InIt last, format fmt = auto_format);

template <class Source>
path(const Source& source, const locale& loc, format fmt = auto_format);

template <class InIt>
path(InIt first, InIt last, const locale& loc, format fmt = auto_format);

Parameters

right
O caminho cujo caminho construído deve ser uma cópia.

source
A fonte cujo caminho construído deve ser uma cópia.

fmt
O nome format do caminho usado para interpretar source o first/last intervalo. O valor padrão é auto_format.

loc
O local especificado.

first
A posição do primeiro elemento a ser copiado.

last
A posição do último elemento a ser copiado.

Observações

Os construtores constroem myname todos de várias formas:

Pois path() é myname().

Pois path(const path& right) é myname(right.myname).

Pois path(path&& right) é myname(right.myname).

Pois path(string_type&& source, format fmt) é myname(move(source)).

Pois template<class Source> path(const Source& source, format fmt) é myname(source).

Para template<class Source> path(const Source& source, const locale& loc, format fmt) isso, myname(source)obtém quaisquer facetas necessárias codecvt de loc.

Pois template<class InIt> path(InIt first, InIt last, format fmt) é myname(first, last).

Para template<class InIt> path(InIt first, InIt last, const locale& loc, format fmt) isso, myname(first, last)obtém quaisquer facetas necessárias codecvt de loc.

O fmt parâmetro seleciona o formato do nome do caminho. No Windows, os formatos nativo e genérico são intercambiáveis, pelo que a implementação da Microsoft ignora fmt.

`path::preferred_separator`

O objeto constante fornece o carácter preferido para separar componentes do caminho, dependendo do sistema operativo anfitrião.

#if _WIN32_C_LIB
static constexpr value_type preferred_separator = L'\\';
#else // assume POSIX
static constexpr value_type preferred_separator = '/';
#endif // filesystem model now defined

Observações

É igualmente permissível, na maioria dos contextos do Windows, usar L'/' no seu lugar.

`path::relative_path`

Devolve o componente de caminho relativo de myname.

path relative_path() const;

Observações

Devolve o componente de caminho relativo de myname, especificamente o sufixo de myname após a remoção root_path().native() e quaisquer separadores redundantes de diretório imediatamente subsequentes. O componente pode estar vazio.

`path::remove_filename`

Remove o nome do ficheiro.

path& remove_filename();

`path::replace_extension`

Substitui a extensão de myname.

path& replace_extension(const path& newext = path());

Parameters

newext
A nova extensão.

Observações

Primeiro, remove o sufixo extension().native() de myname. Então, se !newext.empty() && newext[0] != dot (onde o ponto é *path(".").c_str()), então o ponto é anexado a myname. Então newext é acrescentado a myname.

`path::replace_filename`

Substitui o nome do ficheiro.

path& replace_filename(const path& pval);

Parameters

pval
O caminho do nome do ficheiro.

Observações

A função membro executa:

remove_filename();

*this /= pval;
return (*this);

`path::root_directory`

Devolve o componente de diretório raiz de myname.

path root_directory() const;

Observações

O componente pode estar vazio.

`path::root_name`

Devolve o componente raiz do nome de myname.

path root_name() const;

Observações

O componente pode estar vazio.

`path::root_path`

Devolve o componente do caminho raiz de myname.

path root_path() const;

Observações

Devolve o componente do caminho raiz de myname, especificamente / root_name()root_directory . O componente pode estar vazio.

`path::stem`

Devolve o stem componente de myname.

path stem() const;

Observações

Devolve o stem componente de myname, especificamente filename().native() com qualquer ração extension().native() removida. O componente pode estar vazio.

`path::string`

Converte a sequência armazenada em myname.

template <class Elem, class Traits = char_traits<Elem>, class Alloc = allocator<Elem>>
basic_string<Elem, Traits, Alloc> string(const Alloc& al = Alloc()) const;
string string() const;

Observações

A primeira função membro (modelo) converte a sequência armazenada myname da mesma forma que:

string() para string<char, Traits, Alloc>()
wstring() para string<wchar_t, Traits, Alloc>()
u16string() para string<char16_t, Traits, Alloc>()
u32string() para string<char32_t, Traits, Alloc>()

A segunda função membro converte a sequência armazenada na myname codificação preferida pelo sistema anfitrião para uma char sequência e devolve-a armazenada num objeto do tipo string.

`path::string_type`

O tipo é sinônimo de basic_string<value_type>.

typedef basic_string<value_type> string_type;

`path::swap`

Executa swap(myname, right.myname).

void swap(path& right) noexcept;

`path::u16string`

Converte a sequência armazenada em myname UTF-16 e devolve-a armazenada num objeto do tipo u16string.

u16string u16string() const;

`path::u32string`

Converte a sequência armazenada em myname UTF-32 e devolve-a armazenada num objeto do tipo u32string.

u32string u32string() const;

`path::u8string`

Converte a sequência armazenada em myname UTF-8 e devolve-a armazenada num objeto do tipo u8string.

string u8string() const;

`path::value_type`

O tipo descreve os path elementos preferidos pelo sistema operativo anfitrião.

#if _WIN32_C_LIB
typedef wchar_t value_type;
#else // assume POSIX
typedef char value_type;
#endif // filesystem model now defined

`path::wstring`

Converte a sequência armazenada para myname a codificação preferida pelo sistema anfitrião para uma wchar_t sequência e devolve-a armazenada num objeto do tipo wstring.

wstring wstring() const;

Ver também

<filesystem>
de referência de arquivos de cabeçalho

Comentários

Esta página foi útil?

Última atualização a 2026-08-31

path classe

Sintaxe

Constructors

Typedefs (definições de tipos)

Enumerations

Funções de membro

Operators

Requisitos

path::append

Parameters

path::assign

Parameters

path::begin

path::c_str

path::clear

path::compare

Parameters

path::concat

Parameters

path::const_iterator

path::empty

path::end

path::extension

Observações

path::filename

path::format

Members

Observações

path::generic_string

path::generic_u16string

path::generic_u32string

path::generic_u8string

path::generic_wstring

path::has_extension

path::has_filename

path::has_parent_path

path::has_relative_path

path::has_root_directory

path::has_root_name

path::has_root_path

path::has_stem

path::is_absolute

path::is_relative

path::iterator

Observações

path::lexically_normal

Observações

path::lexically_proximate

Parameters

path::lexically_relative

Parameters

Observações

path::make_preferred

path::native

Observações

path::operator=

Parameters

Observações

path::operator+=

Parameters

Observações

path::operator/=

Parameters

Observações

path::operator string_type

path::parent_path

Observações

path::path

Parameters

Observações

path::preferred_separator

Observações

path::relative_path

Observações

path::remove_filename

path::replace_extension

Parameters

Observações

path::replace_filename

Parameters

`path` classe

`path::append`

`path::assign`

`path::begin`

`path::c_str`

`path::clear`

`path::compare`

`path::concat`

`path::const_iterator`

`path::empty`

`path::end`

`path::extension`

`path::filename`

`path::format`

`path::generic_string`

`path::generic_u16string`

`path::generic_u32string`

`path::generic_u8string`

`path::generic_wstring`

`path::has_extension`

`path::has_filename`

`path::has_parent_path`

`path::has_relative_path`

`path::has_root_directory`

`path::has_root_name`

`path::has_root_path`

`path::has_stem`

`path::is_absolute`

`path::is_relative`

`path::iterator`

`path::lexically_normal`

`path::lexically_proximate`

`path::lexically_relative`

`path::make_preferred`

`path::native`

`path::operator=`

`path::operator+=`

`path::operator/=`

`path::operator string_type`

`path::parent_path`

`path::path`

`path::preferred_separator`

`path::relative_path`

`path::remove_filename`

`path::replace_extension`

`path::replace_filename`

`path::root_directory`

`path::root_name`

`path::root_path`

`path::stem`

`path::string`

`path::string_type`

`path::swap`

`path::u16string`

`path::u32string`

`path::u8string`

`path::value_type`

`path::wstring`