<experimental/filesystem> clase path

La path clase almacena un objeto de tipo string_type, llamado myname aquí para los fines de exposición, adecuado para su uso como pathname. string_typees un sinónimo de basic_string<value_type>, donde value_type es un sinónimo de wchar_t en Windows.

Sintaxis

class path;

Constructores

Typedefs

Funciones miembro

Operators

Requisitos

Encabezado: <experimental/filesystem>

Espacio de nombres:std::experimental::filesystem

path::append

Anexa la secuencia especificada a myname, convertida e insertando una preferred_separator según sea necesario.

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

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

Parameters

source
Secuencia especificada.

first
Inicio de la secuencia especificada.

last
Fin de la secuencia especificada.

path::assign

myname Reemplaza por la secuencia especificada, convertida según sea necesario.

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

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

Parameters

source
Secuencia especificada.

first
Inicio de la secuencia especificada.

last
Fin de la secuencia especificada.

path::begin

Devuelve un path::iterator elemento que designa el primer elemento de ruta de acceso en pathname, si está presente.

iterator begin() const;

path::c_str

Devuelve un puntero al primer carácter de myname.

const value_type* c_str() const noexcept;

path::clear

myname.clear()Ejecuta.

void clear() noexcept;

path::compare

La primera función devuelve myname.compare(pval.native()). La segunda función devuelve myname.compare(str). La tercera función devuelve 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
Ruta de acceso que se va a comparar.

str
Cadena que se va a comparar.

ptr
Puntero que se va a comparar.

path::concat

Anexa la secuencia especificada a myname, convertida (pero no insertando un separador) según sea necesario.

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

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

Parameters

source
Secuencia especificada.

first
Inicio de la secuencia especificada.

last
Fin de la secuencia especificada.

path::const_iterator

Sinónimo de iterator.

typedef iterator const_iterator;

path::empty

Devuelve myname.empty().

bool empty() const noexcept;

path::end

Devuelve un iterador de fin de secuencia de tipo iterator.

iterator end() const;

path::extension

Devuelve el sufijo de filename().

path extension() const;

Observaciones

Devuelve el sufijo de filename() X tal manera que:

Si X == path(".") || X == path("..") o si X no contiene ningún punto, el sufijo está vacío.

De lo contrario, el sufijo comienza por (e incluye) el punto más a la derecha.

path::filename

Devuelve el componente de nombre de archivo de myname, específicamente empty() ? path() : *--end(). El componente puede estar vacío.

path filename() const;

path::generic_string

Devuelve this->string<Elem, Traits, Alloc>(al) con (en Windows) cualquier barra diagonal inversa convertida en una barra diagonal.

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

Devuelve u16string() con (en Windows) cualquier barra diagonal inversa convertida en una barra diagonal.

u16string generic_u16string() const;

path::generic_u32string

Esta función se elimina en la implementación histórica de MSVC.

u32string generic_u32string() const = delete;

path::generic_u8string

Devuelve u8string() con (en Windows) cualquier barra diagonal inversa convertida en una barra diagonal.

string generic_u8string() const;

path::generic_wstring

Devuelve wstring() con (en Windows) cualquier barra diagonal inversa convertida en una barra diagonal.

wstring generic_wstring() const;

path::has_extension

Devuelve !extension().empty().

bool has_extension() const;

path::has_filename

Devuelve !filename().empty().

bool has_filename() const;

path::has_parent_path

Devuelve !parent_path().empty().

bool has_parent_path() const;

path::has_relative_path

Devuelve !relative_path().empty().

bool has_relative_path() const;

path::has_root_directory

Devuelve !root_directory().empty().

bool has_root_directory() const;

path::has_root_name

Devuelve !root_name().empty().

bool has_root_name() const;

path::has_root_path

Devuelve !root_path().empty().

bool has_root_path() const;

path::has_stem

Devuelve !stem().empty().

bool has_stem() const;

path::is_absolute

Para Windows, la función devuelve has_root_name() && has_root_directory(). Para POSIX, la función devuelve has_root_directory().

bool is_absolute() const;

path::is_relative

Devuelve !is_absolute().

bool is_relative() const;

path::iterator

Iterador de constante bidireccional que designa los componentes de ruta de acceso 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;
   // ...
   };

Observaciones

La clase describe un iterador de constante bidireccional que designa los path componentes de myname en la secuencia:

1. el nombre raíz, si está presente

2. el directorio raíz, si está presente

3. los elementos de directorio restantes del elemento primario path, si están presentes, finalizando con el nombre de archivo, si está presente.

Para pval un objeto de tipo path:

1. path::iterator X = pval.begin() designa el primer path elemento del pathname, si está presente.

2. X == pval.end()es cuando X apunta true justo después del final de la secuencia de componentes.

3. *X devuelve una cadena que coincide con el componente actual.

4. ++X designa el siguiente componente de la secuencia, si está presente.

5. --X designa el componente anterior en la secuencia, si está presente.

6. Modificar invalida myname todos los iteradores que designan elementos en myname.

path::make_preferred

Convierte cada separador en según preferred_separator sea necesario.

path& make_preferred();

path::native

Obtenga la representación de cadena nativa de la ruta de acceso.

const string_type& native() const noexcept;

Observaciones

La ruta de acceso está disponible en un formato genérico portátil (vea generic_string()) o el formato nativo de la ruta de acceso. Esta función devuelve la cadena nativa. En un sistema POSIX, el formato genérico y el formato nativo son los mismos.

En el ejemplo siguiente que se ejecuta en Windows, la cadena de ruta de acceso genérica es c:/t/temp.txt y la cadena nativa es 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=

Reemplaza los elementos de la ruta de acceso por una copia de otra ruta de acceso.

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

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

Parameters

right
objeto path que se copia en .path

source
pathOrigen .

Observaciones

El primer operador miembro copia right.myname en myname. El segundo operador miembro se mueve right.myname a myname. El tercer operador miembro se comporta igual que *this = path(source).

path::operator+=

Varias concat expresiones.

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
Ruta de acceso agregada.

str
Cadena agregada.

ptr
Puntero agregado.

elem
Agregado value_type o Elem.

source
Origen agregado.

Observaciones

Las funciones miembro se comportan igual que las siguientes expresiones correspondientes:

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/=

Varias append expresiones.

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

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

Parameters

right
Ruta de acceso agregada.

source
Origen agregado.

Observaciones

Las funciones miembro se comportan igual que las siguientes expresiones correspondientes:

1. append(right);

2. append(source);

path::operator string_type

Devuelve myname.

operator string_type() const;

path::parent_path

Devuelve el componente de ruta de acceso principal de myname.

path parent_path() const;

Observaciones

Devuelve el componente de ruta de acceso principal de myname, específicamente el prefijo de después de myname quitar filename().native() y los separadores de directorio inmediatamente anteriores. (Igualmente, si begin() != end()es , es la combinación de todos los elementos del intervalo [begin(), --end()) aplicando operator/=sucesivamente ). El componente puede estar vacío.

path::path

Construye un objeto path de varias maneras.

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
Ruta de acceso de la que se va a copiar la ruta de acceso construida.

source
Origen del que la ruta de acceso construida es una copia.

loc
Configuración regional especificada.

first
Posición del primer elemento que se va a copiar.

last
Posición del último elemento que se va a copiar.

Observaciones

Todos los constructores construyen myname de varias maneras:

Para path() eso es myname().

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

Para path(path&& right) eso es myname(right.myname).

Para template<class Source> path(const Source& source) eso es myname(source).

Para template<class Source> path(const Source& source, const locale& loc) ello, myname(source)obtiene las facetas necesarias codecvt de loc.

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

Para template<class InIt> path(InIt first, InIt last, const locale& loc) ello, myname(first, last)obtiene las facetas necesarias codecvt de loc.

path::preferred_separator

El objeto constante proporciona el carácter preferido para separar los componentes de ruta de acceso, en función del sistema operativo 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

Observaciones

Es igualmente permisible en la mayoría de los contextos bajo Windows usar L'/' en su lugar.

path::relative_path

Devuelve el componente de ruta de acceso relativa de myname.

path relative_path() const;

Observaciones

Devuelve el componente de ruta de acceso relativa de myname, específicamente el sufijo de después de myname quitar root_path().native() y los separadores de directorio redundantes inmediatamente posteriores. El componente puede estar vacío.

path::remove_filename

Quita el nombre de archivo.

path& remove_filename();

path::replace_extension

Reemplaza la extensión de myname.

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

Parameters

newext
Nueva extensión.

Observaciones

En primer lugar, quita el sufijo extension().native() de myname. A continuación, si !newext.empty() && newext[0] != dot (donde dot es *path(".").c_str()), el punto se anexa a myname. A continuación newext , se anexa a myname.

path::replace_filename

Reemplaza el nombre de archivo.

path& replace_filename(const path& pval);

Parameters

pval
Ruta de acceso del nombre de archivo.

Observaciones

La función miembro ejecuta:

remove_filename();

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

path::root_directory

Devuelve el componente de directorio raíz de myname.

path root_directory() const;

Observaciones

El componente puede estar vacío.

path::root_name

Devuelve el componente de nombre raíz de myname.

path root_name() const;

Observaciones

El componente puede estar vacío.

path::root_path

Devuelve el componente de ruta de acceso raíz de myname.

path root_path() const;

Observaciones

Devuelve el componente de ruta de acceso raíz de myname, específicamente / root_name()root_directory . El componente puede estar vacío.

path::stem

Devuelve el stem componente de myname.

path stem() const;

Observaciones

Devuelve el stem componente de myname, específicamente filename().native() con cualquier final quitado extension().native() . El componente puede estar vacío.

path::string

Convierte la secuencia almacenada en 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;

Observaciones

La primera función miembro (plantilla) convierte la secuencia almacenada myname de la misma manera que:

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

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

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

La segunda función miembro convierte la secuencia almacenada en myname en la codificación favorecida por el sistema host para una char secuencia y la devuelve almacenada en un objeto de tipo string.

path::string_type

El tipo es un sinónimo de basic_string<value_type>.

typedef basic_string<value_type> string_type;

path::swap

swap(myname, right.myname)Ejecuta.

void swap(path& right) noexcept;

path::u16string

Convierte la secuencia almacenada en myname UTF-16 y la devuelve almacenada en un objeto de tipo u16string.

u16string u16string() const;

path::u32string

Esta función se elimina en la implementación histórica de MSVC.

u32string u32string() const = delete;

path::u8string

Convierte la secuencia almacenada en myname UTF-8 y la devuelve almacenada en un objeto de tipo u8string.

string u8string() const;

path::value_type

El tipo describe los path elementos preferidos por el sistema operativo host.

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

path::wstring

Convierte la secuencia almacenada en myname en la codificación favorecida por el sistema host para una wchar_t secuencia y la devuelve almacenada en un objeto de tipo wstring.

wstring wstring() const;

Consulte también

<experimental/filesystem>
<experimental/filesystem> operadores