<experimental/filesystem> Classe de percurso

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é um sinónimo de basic_string<value_type>, onde value_type é um sinónimo de wchar_t no Windows.

Sintaxe

class path;

Constructors

Typedefs (definições de tipos)

Funções de membro

Operators

Requisitos

Cabeçalho:<experimental/filesystem>

Espaço de nomes:std::experimental::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.

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 devolve myname.compare(pval.native()). A segunda função devolve myname.compare(str). A terceira função devolve myname.compare(ptr).

int compare(const path& pval) const noexcept;
int compare(const string_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::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

Esta função foi eliminada na implementação histórica do MSVC.

u32string generic_u32string() const = delete;

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:

1. o nome raiz, se presente

2. o diretório raiz, se estiver presente

3. 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:

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

2. X == pval.end() é true quando X aponta logo para além do fim da sequência de componentes.

3. *X devolve uma cadeia que corresponde ao componente atual

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

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

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

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++14 and _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING defined.
#include <experimental/filesystem>

int main()
{
    std::experimental::filesystem::path p(LR"(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);

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 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+=(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 membros comportam-se da mesma forma 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/=

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:

1. append(right);

2. 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();

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);

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.

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().

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

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

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

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

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

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

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:

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

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

3. u16string() para string<char16_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

Esta função foi eliminada na implementação histórica do MSVC.

u32string u32string() const = delete;

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

<experimental/filesystem>
<experimental/filesystem> Operadores