Classe path

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

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

Sintaxe

class path;

Construtores

Typedefs

Funções de membro

Operadores

Requisitos

Cabeçalho: <filesystem>

Namespace: std::experimental::filesystem

path::append

Acrescenta a sequência especificada a mypath, convertida e inserindo um preferred_separator conforme necessário.

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

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

Parâmetros

source
A sequência especificada.

first
O início da sequência especificada.

last
O fim da sequência especificada.

path::assign

Substitui mypath com a sequência especificada, convertida conforme necessário.

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

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

Parâmetros

source
A sequência especificada.

first
O início da sequência especificada.

last
O fim da sequência especificada.

path::begin

Retorna um path::iterator designando o primeiro elemento de caminho no nome do caminho, se existir.

iterator begin() const;

path::c_str

Retorna um ponteiro para o primeiro caractere em mypath.

const value_type& *c_str() const noexcept;

path::clear

Executa mypath.clear().

void clear() noexcept;

path::compare

A primeira função retorna mypath.compare(pval.native()). A segunda função retorna mypath.compare(str). A terceira função retorna mypath.compare(ptr).

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

Parâmetros

pval
O caminho a ser comparado.

str
A cadeia de caracteres a ser comparada.

ptr
O ponteiro a ser comparado.

path::concat

Acrescenta a sequência especificada a mypath, convertida (mas não inserindo um separador) conforme necessário.

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

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

Parâmetros

source
A sequência especificada.

first
O início da sequência especificada.

last
O fim da sequência especificada.

path::const_iterator

Um sinônimo de iterator.

typedef iterator const_iterator;

path::empty

Retorna mypath.empty().

bool empty() const noexcept;

path::end

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

iterator end() const;

path::extension

Retorna o sufixo de filename().

path extension() const;

Comentários

Retorna o sufixo de filename() X, de modo que:

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

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

path::filename

Retorna o componente do diretório raiz de myname, especificamente empty() path() : *--end(). O componente pode estar vazio.

path filename() const;

path::generic_string

Retorna this->string<Elem, Traits, Alloc>(al) com (em Windows) qualquer barra invertida convertida em barra "/".

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

Retorna u16string() com (em Windows) qualquer barra invertida convertida em barra "/".

u16string generic_u16string() const;

path::generic_u32string

Retorna u32string() com (em Windows) qualquer barra invertida convertida em barra "/".

u32string generic_u32string() const;

path::generic_u8string

Retorna u8string() com (em Windows) qualquer barra invertida convertida em barra "/".

string generic_u8string() const;

path::generic_wstring

Retorna wstring() com (em Windows) qualquer barra invertida convertida em barra "/".

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 retorna has_root_name() && has_root_directory(). Para o POSIX, a função retorna has_root_directory().

bool is_absolute() const;

path::is_relative

Retorna !is_absolute().

bool is_relative() const;

path::iterator

Um iterador de constante bidirecional que designa os componentes path 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;
   // ...
   };

Comentários

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

1. o nome raiz, se existir

2. o diretório raiz, se existir

3. os elementos de diretório restantes do path pai, se existirem, terminando com o nome do arquivo, se existir

Para pval, um objeto do tipo path:

1. path::iterator X = pval.begin() designa o primeiro elemento path no nome do caminho, se existir.

2. X == pval.end() é true quando X aponta para logo após o final da sequência de componentes.

3. *X retorna uma cadeia de caracteres que corresponde ao componente atual

4. ++X designa o próximo componente na sequência, se existir.

5. --X designa o componente anterior na sequência, se existir.

6. Alterar myname invalida todos os iteradores que designam elementos em myname.

path::make_preferred

Converte cada separador em um preferred_separator, conforme necessário.

path& make_preferred();

path::native

Obtenha a representação de cadeia de caracteres nativa do caminho.

const string_type& native() const noexcept;

Comentários

O caminho está disponível em um formato genérico portátil (consulte generic_string()) ou no formato nativo do caminho. Essa função retorna a cadeia de caracteres nativa. Em um sistema POSIX, o formato genérico e o formato nativo são os mesmos.

No exemplo a seguir em execução no Windows 11, a cadeia de caracteres de caminho genérico é c:/t/temp/temp.txt e a cadeia de caracteres 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;

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

Parâmetros

right
O path que está sendo copiado no path.

source
A fonte de path.

Comentários

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

path::operator+=

Diversas expressões concat.

path& operator+=(const path& right);
path& operator+=(const string_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);

Parâmetros

right
O caminho adicionado.

str
A cadeia de caracteres adicionada.

ptr
O ponteiro adicionado.

elem
O value_type ou Elem adicionado.

source
A fonte adicionada.

Comentários

As funções de membro se comportam da mesma maneira que as seguintes expressões correspondentes:

1. concat(right);

2. concat(path(str));

3. concat(ptr);

4. concat(string_type(1, elem));

5. concat(source);

6. concat(path(basic_string<Elem>(1, elem)));

path::operator/=

Diversas expressões append.

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

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

Parâmetros

right
O caminho adicionado.

source
A fonte adicionada.

Comentários

As funções de membro se comportam da mesma maneira que as seguintes expressões correspondentes:

1. append(right);

2. append(source);

path::operator string_type

Retorna myname.

operator string_type() const;

path::parent_path

Retorna o componente de caminho pai de myname.

path parent_path() const;

Comentários

Retorna o componente de caminho pai de myname, especificamente o prefixo de myname após a remoção de filename().native() e qualquer separador de diretório imediatamente anterior. (Da mesma forma, se begin() != end(), é a combinação de todos os elementos no intervalo [begin(), --end()) aplicando operator/= sucessivamente.) O componente pode estar vazio.

path::path

Constrói um de path várias maneiras.

path();

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

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

template <class Source>
path(const Source& source, const locale& loc);

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

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

Parâmetros

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

source
A origem da qual o caminho construído deve ser uma cópia.

loc
A localidade especificada.

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

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

Comentários

Todos os construtores criam myname de várias maneiras:

Para path(), é myname().

Para path(const path& right, é myname(right.myname).

Para path(path&& right), é myname(right.myname).

Para template<class Source> path(const Source& source), é myname(source).

Para template<class Source> path(const Source& source, const locale& loc) ele é myname(source), obtendo todas as facetas codecvt necessárias de loc.

Para template<class InIt> path(InIt first, InIt last), é myname(first, last).

Para template<class InIt> path(InIt first, InIt last, const locale& loc) ele é myname(first, last), obtendo todas as facetas codecvt necessárias de loc.

path::preferred_separator

O objeto constante fornece o caractere preferencial para separar os componentes do caminho, dependendo do sistema operacional do host.

#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

Comentários

Usar L'/' em lugar dele é igualmente permitido na maioria dos contextos no Windows.

path::relative_path

Retorna o componente de caminho relativo de myname.

path relative_path() const;

Comentários

Retorna o componente de caminho relativo de myname, especificamente o sufixo de myname após remover root_path().native() e os separadores de diretório imediatamente subsequentes, se houver. O componente pode estar vazio.

path::remove_filename

Remove o nome do arquivo.

path& remove_filename();

path::replace_extension

Substitui a extensão de myname.

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

Parâmetros

newext
A nova extensão.

Comentários

Primeiro, remove o sufixo extension().native() de myname. Depois, se !newext.empty() && newext[0] != dot (em que dot é *path(".").c_str()), então dot é acrescentado a myname. Em seguida, newext é acrescentado a myname.

path::replace_filename

Substitui o nome do arquivo.

path& replace_filename(const path& pval);

Parâmetros

pval
O caminho do nome do arquivo.

Comentários

A função membro executa:

remove_filename();

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

path::root_directory

Retorna o componente do diretório raiz de myname.

path root_directory() const;

Comentários

O componente pode estar vazio.

path::root_name

Retorna o componente de nome raiz de myname.

path root_name() const;

Comentários

O componente pode estar vazio.

path::root_path

Retorna o componente de caminho raiz de myname.

path root_path() const;

Comentários

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

path::stem

Retorna o componente stem de myname.

path stem() const;

Comentários

Retorna o componente stem de myname, especificamente filename().native(), removendo eventuais ocorrências de extension().native() à direita. O componente pode estar vazio.

path::string

Converte a sequência armazenada em mypath.

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;

Comentários

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

1. string() para string<char, Traits, Alloc>()

2. wstring() para string<wchar_t, Traits, Alloc>()

3. u16string() para string<char16_t, Traits, Alloc>()

4. u32string() para string<char32_t, Traits, Alloc>()

A segunda função membro converte a sequência armazenada em mypath na codificação preferida pelo sistema de host para uma sequência char armazenada em um objeto do tipo string.

path::string_type

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

typedef basic_string<value_type> string_type;

path::swap

Executa swap(mypath, right.mypath).

void swap(path& right) noexcept;

path::u16string

Converte a sequência armazenada em mypath em UTF-16 e a retorna armazenada em um objeto do tipo u16string.

u16string u16string() const;

path::u32string

Converte a sequência armazenada em mypath em UTF-32 e a retorna armazenada em um objeto do tipo u32string.

u32string u32string() const;

path::u8string

Converte a sequência armazenada em mypath em UTF-8 e a retorna armazenada em um objeto do tipo u8string.

string u8string() const;

path::value_type

O tipo descreve os elementos path preferidos pelo sistema operacional do host.

#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 em mypath na codificação preferida pelo sistema de host para uma sequência wchar_t e a retorna armazenada em um objeto do tipo wstring.

wstring wstring() const;

Confira também

Referência de Arquivos de Cabeçalho