clase path

La clase path almacena un objeto de tipo string_type, denominado aquí myname a efectos de la exposición, que se puede usar como un nombre de ruta de acceso. string_type es un sinónimo de basic_string<value_type>, donde value_type es un sinónimo de wchar_t en Windows o char en POSIX.

La path clase que se describe aquí es la clase C++17 std::filesystem::path en el <filesystem> encabezado .

Para obtener más información y ejemplos de código, vea Exploración del sistema de archivos (C++).

Sintaxis

class path;

Constructores

Typedefs

Enumerations

Funciones miembro

Operadores

Requisitos

Encabezado: <filesystem>

Espacio de nombres: std::filesystem

path::append

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

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

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

Parámetros

source
Secuencia especificada.

first
Inicio de la secuencia especificada.

last
Fin de la secuencia especificada.

path::assign

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

path& assign(string_type&& source);

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

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

Parámetros

source
Secuencia especificada.

first
Inicio de la secuencia especificada.

last
Fin de la secuencia especificada.

path::begin

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

iterator begin() const;

path::c_str

Devuelve un puntero al primer carácter en myname.

const value_type* c_str() const noexcept;

path::clear

Ejecuta myname.clear().

void clear() noexcept;

path::compare

La primera función compara los elementos de esta ruta de acceso con pval. Las otras funciones crean una ruta de acceso a partir de su argumento y devuelven el resultado de compararla con esta ruta de acceso.

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;

Parámetros

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

Parámetros

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 final de secuencia de tipo iterator.

iterator end() const;

path::extension

Devuelve el sufijo de filename().

path extension() const;

Comentarios

Devuelve el sufijo de filename() X tal 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 con (e incluye) el punto situado más al 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::format

Especifica el formato pathname usado para interpretar la secuencia de caracteres que se pasa a un path constructor.

enum format {
    auto_format,
    native_format,
    generic_format
};

Members

Comentarios

Dado que el formato nativo y el formato genérico son intercambiables en Windows, la implementación de Microsoft trata los tres enumeradores iguales. El format parámetro se proporciona para la conformidad estándar y la portabilidad. Para obtener más información, vea la especificación WG21 N4659 [fs.class.path].

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

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

u32string generic_u32string() const;

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

Un iterador 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;
   // ...
   };

Comentarios

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

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

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

3. los elementos restantes del directorio de path primaria, si está presente, que terminan con el nombre de archivo, si está presente

Para pval un objeto de tipo path:

1. path::iterator X = pval.begin() designa el primer elemento path en el nombre de ruta de acceso, si está presente.

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

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

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

5. --X designa el componente anterior de la secuencia, si existe.

6. Al modificar myname se invalidan todos los iteradores que designan elementos en myname.

path::lexically_normal

Devuelve myname convertido a forma normal. La conversión es puramente léxica: no se tiene acceso al sistema de archivos.

path lexically_normal() const;

Comentarios

La normalización contrae elementos redundantes, como . y y .. separadores de directorios. Por ejemplo, path("a/./b/../c").lexically_normal() produce a\c en Windows. Una ruta de acceso vacía normaliza una ruta de acceso vacía; una ruta de acceso que reduce a nada normaliza en .. Para obtener el algoritmo de normalización completo, consulte la especificación WG21 N4659 [fs.path.generic].

path::lexically_proximate

Devuelve el resultado de lexically_relative(base). Si ese resultado es una ruta de acceso vacía, devuelve una copia de *this en su lugar.

path lexically_proximate(const path& base) const;

Parámetros

base
Ruta de acceso base a la que se va a convertir *this proximate.

path::lexically_relative

Devuelve myname realizado en relación con base, usando solo análisis léxico (cadena). No se tiene acceso al sistema de archivos.

path lexically_relative(const path& base) const;

Parámetros

base
Ruta de acceso base a la que se va a establecer *this en relación.

Comentarios

Si root_name() != base.root_name()es , o si una ruta de acceso es absoluta y la otra es relativa, o si la ruta de acceso tiene un nombre de archivo pero no un directorio raíz mientras la base no lo hace, devuelve una ruta de acceso vacía. De lo contrario, determina la ruta de acceso relativa de base a mediante la búsqueda del primer elemento no coincidente y la emisión .. de cada elemento restante de base, seguido de los elementos restantes de *this*this . Por ejemplo, path("/a/d").lexically_relative("/a/b/c") produce ..\..\d. Para obtener el algoritmo completo, consulte la especificación WG21 N4659 [fs.path.gen].

path::make_preferred

Convierte cada separador a un preferred_separator según 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;

Comentarios

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

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;
path& operator=(string_type&& source);

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

Parámetros

right
La clase path que se copia en path.

source
path de origen.

Comentarios

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

path::operator+=

Varias expresiones concat.

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

Parámetros

right
La ruta de acceso agregada.

str
La cadena agregada.

ptr
El puntero agregado.

elem
Los value_type o Elem agregados.

source
El origen agregado.

Comentarios

Las funciones miembro se comportan igual que las llamadas concat con el argumento . Las pathsobrecargas terminadas en , string_typebasic_string_view, y null value_type* concatenan la secuencia de caracteres del argumento. Las value_type sobrecargas y Elem concatenan un solo carácter. La sobrecarga con Source plantilla concatena la secuencia de origen convertida.

path::operator/=

Varias expresiones append.

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

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

Parámetros

right
La ruta de acceso agregada.

source
El origen agregado.

Comentarios

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 primaria de myname.

path parent_path() const;

Comentarios

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

path::path

Construye una path de varias maneras.

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

Parámetros

right
La ruta de acceso de la que se va a copiar la ruta de acceso construida.

source
El origen del que se va a copiar la ruta de acceso construida.

fmt
Pathname format usado para interpretar source o el first/last intervalo. Tiene como valor predeterminado auto_format.

loc
La 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.

Comentarios

Todos los constructores construyen myname de varias maneras:

Para path() es myname().

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

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

Para path(string_type&& source, format fmt) es myname(move(source)).

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

Para template<class Source> path(const Source& source, const locale& loc, format fmt) es myname(source), obteniendo las facetas codecvt necesarias desde loc.

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

Para template<class InIt> path(InIt first, InIt last, const locale& loc, format fmt) es myname(first, last), obteniendo las facetas codecvt necesarias desde loc.

El fmt parámetro selecciona el formato pathname. En Windows, los formatos nativos y genéricos son intercambiables, por lo que la implementación de Microsoft omite fmt.

path::preferred_separator

El objeto constante ofrece el carácter preferido para separar los componentes de la ruta de acceso, según el 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

Comentarios

En la mayoría de los contextos en Windows también se permite usar L'/' en su lugar.

path::relative_path

Devuelve el componente de ruta de acceso relativa de myname.

path relative_path() const;

Comentarios

Devuelve el componente de ruta de acceso relativa de myname, específicamente el sufijo de myname después de 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());

Parámetros

newext
La nueva extensión.

Comentarios

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()), entonces dot se anexa a myname. Después newext se anexa a myname.

path::replace_filename

Reemplaza el nombre de archivo.

path& replace_filename(const path& pval);

Parámetros

pval
La ruta de acceso del nombre de archivo.

Comentarios

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;

Comentarios

El componente puede estar vacío.

path::root_name

Devuelve el componente de nombre raíz de myname.

path root_name() const;

Comentarios

El componente puede estar vacío.

path::root_path

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

path root_path() const;

Comentarios

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 componente stem de myname.

path stem() const;

Comentarios

Devuelve el componente stem de myname, específicamente filename().native() quitando cualquier extension().native() final. 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;

Comentarios

La primera función miembro (plantilla) convierte la secuencia almacenada en myname del mismo modo 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>()

La segunda función miembro convierte la secuencia almacenada en myname a la codificación preferida de sistema host para una secuencia char 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

Ejecuta swap(myname, right.myname).

void swap(path& right) noexcept;

path::u16string

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

u16string u16string() const;

path::u32string

Convierte la secuencia almacenada en myname a UTF-32 y la devuelve almacenada en un objeto de tipo u32string.

u32string u32string() const;

path::u8string

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

string u8string() const;

path::value_type

El tipo describe los elementos path preferidos del sistema operativo anfitrión.

#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 a la codificación preferida de sistema host para una secuencia wchar_t y la devuelve almacenada en un objeto de tipo wstring.

wstring wstring() const;

Consulte también

<filesystem>
Referencia de archivos de encabezado