<experimental/filesystem> classe path

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

Sintaxe

class path;

Constructors

Typedefs

Funções de membro

Operadores

Requirements

Cabeçalho:<experimental/filesystem>

Namespace:std::experimental::filesystem

path::append

Acrescenta a sequência especificada a myname, convertida e inserindo uma 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
Sequência especificada.

first
Início da sequência especificada.

last
Fim da sequência especificada.

path::assign

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

Parâmetros

source
Sequência especificada.

first
Início da sequência especificada.

last
Fim da sequência especificada.

path::begin

Retorna uma path::iterator designação do primeiro elemento de caminho no nome do caminho, se presente.

iterator begin() const;

path::c_str

Retorna um ponteiro para o primeiro caractere em myname.

const value_type* c_str() const noexcept;

path::clear

Executa myname.clear().

void clear() noexcept;

path::compare

A primeira função retorna myname.compare(pval.native()). A segunda função retorna myname.compare(str). A terceira função retorna myname.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
Caminho a ser comparado.

str
Cadeia de caracteres a ser comparada.

ptr
Ponteiro a ser comparado.

path::concat

Acrescenta a sequência especificada a myname, 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
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

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

iterator end() const;

path::extension

Retorna o sufixo de filename().

path extension() const;

Observações

Retorna o sufixo de filename() X tal forma que:

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

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

path::filename

Retorna o componente filename 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 uma barra dianteira.

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 uma barra dianteira.

u16string generic_u16string() const;

path::generic_u32string

Essa função é excluída na implementação histórica do MSVC.

u32string generic_u32string() const = delete;

path::generic_u8string

Retorna u8string() com (em Windows) qualquer barra invertida convertida em uma barra dianteira.

string generic_u8string() const;

path::generic_wstring

Retorna wstring() com (em Windows) qualquer barra invertida convertida em uma barra dianteira.

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 Windows, a função retorna has_root_name() && has_root_directory(). Para 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 de 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 de constante bidirecional que designa os path componentes da myname sequência:

1. o nome raiz, se presente

2. o diretório raiz, se presente

3. os elementos de diretório restantes do pai path, se estiverem presentes, terminando com o nome do arquivo, se estiverem 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 pontos 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 presente.

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

6. A alteração 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;

Observações

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, a cadeia de caracteres de caminho genérico é c:/t/temp.txt e a cadeia de caracteres 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);

Parâmetros

right
O path que está sendo copiado para o path.

source
A origem path.

Observações

O primeiro operador membro copia right.myname para myname. O segundo operador membro passa right.myname para myname. O terceiro operador membro se comporta 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);

Parâmetros

right
O caminho adicionado.

str
A cadeia de caracteres adicionada.

ptr
O ponteiro adicionado.

elem
O adicionado value_type ou Elem.

source
A origem adicionada.

Observações

As funções de membro se comportam 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);

Parâmetros

right
O caminho adicionado.

source
A origem adicionada.

Observações

As funções de membro se comportam 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

Retorna o componente de caminho pai de myname.

path parent_path() const;

Observações

Retorna o componente de caminho pai de myname, especificamente o prefixo de myname após a remoção filename().native() e quaisquer separadores de diretório imediatamente anteriores. (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.

Observações

Todos os construtores são construídos myname de várias maneiras:

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) ele, myname(source)obtendo todas as 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) ele, myname(first, last)obtendo todas as facetas necessárias codecvt de loc.

path::preferred_separator

O objeto constante fornece o caractere preferencial para separar componentes de caminho, dependendo do sistema operacional 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

Observações

É igualmente permitido na maioria dos contextos em Windows para usar L'/' em seu lugar.

path::relative_path

Retorna o componente de caminho relativo de myname.

path relative_path() const;

Observações

Retorna o componente de caminho relativo de myname, especificamente o sufixo de myname após a remoção root_path().native() e quaisquer separadores de diretório redundantes imediatamente subsequentes. 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.

Observações

Primeiro remove o sufixo extension().native() de myname. Em seguida, se !newext.empty() && newext[0] != dot (onde o ponto está *path(".").c_str()), o ponto será 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.

Observações

A função membro é executada:

remove_filename();

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

path::root_directory

Retorna o componente de diretório raiz de myname.

path root_directory() const;

Observações

O componente pode estar vazio.

path::root_name

Retorna o componente de nome raiz de myname.

path root_name() const;

Observações

O componente pode estar vazio.

path::root_path

Retorna o componente de caminho raiz de myname.

path root_path() const;

Observações

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

path::stem

Retorna o stem componente de myname.

path stem() const;

Observações

Retorna o stem componente de myname, especificamente filename().native() com qualquer trailing extension().native() removido. 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 de 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 favorecida pelo sistema host para uma char sequência e a retorna 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(myname, right.myname).

void swap(path& right) noexcept;

path::u16string

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

u16string u16string() const;

path::u32string

Essa função é excluída na implementação histórica do MSVC.

u32string u32string() const = delete;

path::u8string

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

string u8string() const;

path::value_type

O tipo descreve os path elementos favorecidos pelo sistema operacional 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 na myname codificação favorecida pelo sistema host para uma wchar_t sequência e a retorna armazenada em um objeto do tipo wstring.

wstring wstring() const;

Consulte também

<experimental/filesystem>
<experimental/filesystem> operadores