path (Clase, biblioteca de plantillas estándar de C++)

 

Publicado: octubre de 2016

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

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

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

class path;  

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

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

Las funciones miembro anexan la secuencia especificada a mypath convertida e insertan un preferred_separator según sea necesario.

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

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

Las funciones miembro reemplazan mypath con la secuencia especificada, convertida según sea necesario.

iterator begin() const;

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

const value_type& *c_str() const noexcept;  

Devuelve un puntero al primer carácter de mypath.

void clear() noexcept;  

La función miembro ejecuta mypath.clear()

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

 
int compare(const value_type *ptr) const;

La primera función devuelve mypath.compare(pval.native()). La segunda función devuelve mypath.compare(str). La tercera función devuelve mypath.compare(ptr).

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

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

Las funciones miembro anexan la secuencia especificada a mypath, convertida según sea necesario (pero no insertan un preferred_separator).

typedef iterator const_iterator;  

El tipo es un sinónimo de iterador.

bool empty() const noexcept;  

Devuelve mypath.empty().

iterator end() const;

Devuelve un iterador de final de secuencia de tipo iterador.

path extension() const;

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

Devuelve el componente del directorio raíz del myname, específicamente empty() path() : *--end(). El componente puede estar vacío.

template <class Elem,  
    class Traits = char_traits<Elem>,  
    class Alloc = allocator<Elem>>  
basic_string<Elem, Traits, Alloc>  
    generic_string(const Alloc& al = Alloc()) const;

 
STD string generic_string() const;

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

STD u16string generic_u16string() const;

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

STD u32string generic_u32string() const;

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

STD string generic_u8string() const;

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

STD wstring generic_wstring() const;

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

bool has_extension() const;

Devuelve !extension().empty().

bool has_filename() const;

Devuelve !filename().empty().

 
bool has_parent_path() const;

Devuelve !parent_path().empty().

bool has_relative_path() const;

Devuelve !relative_path().empty().

bool has_root_directory() const;

Devuelve !root_directory().empty().

bool has_root_name() const;

Devuelve !root_name().empty().

bool has_root_path() const;

Devuelve !root_path().empty().

bool has_stem() const;

Devuelve !stem().empty().

bool is_absolute() const;

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

bool is_relative() const;

Devuelve !is_absolute().

iterador (clase)
{/ / Iterador bidireccional para la ruta de acceso
TypeDef bidirectional_iterator_tag iterator_category;
TypeDef path_type value_type;
TypeDef ptrdiff_t difference_type;
TypeDef const value_type * puntero;
TypeDef const value_type aspecto referencia;
.....
};

La clase describe un iterador constante bidireccional que designa los componentes de la ruta de acceso 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 la ruta de acceso principal, 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 de la ruta de acceso 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 próximo componente 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& make_preferred();

La función miembro convierte cada separador en un preferred_separator según sea necesario.

const string_type& native() const noexcept;  

Devuelve myname.

path& operator=(const path& right);

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

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

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

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 (ruta de acceso (basic_string<>>(1, elem)));

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

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

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

  1. append(right);

  2. append(source);

''' operador string_type() const;

  
 The member operator returns myname.  
  
## path::parent_path  
  

ruta de acceso parent_path() const;

  
 Returns the parent path component of myname, specifically the prefix of myname after removing filename().native() and any immediately preceding directory separators. (Equally, if begin() != end(), it is the combining of all elements in the range [begin(), --end()) by successively applying operator/=.) The component may be empty.  
  
## path::path  
  

Path();

Path (ruta de acceso const aspecto derecha);

Path(path&& Right) noexcept;
plantilla
ruta de acceso (const origen aspecto origen);

plantilla
ruta de acceso (const origen aspecto origen, const regional aspecto loc);

plantilla
ruta de acceso (InIt en primer lugar, InIt última);

plantilla
ruta de acceso (InIt primero, la configuración regional última, const InIt aspecto loc);

  
 The constructors all construct myname in various ways:  
  
 For path() it is myname().  
  
 For path(const path& right) it is myname(right.myname).  
  
 For path(path&& right) it is myname(right.myname).  
  
 For template<class Source\> path(const Source& source) it is myname(source).  
  
 For template<class Source\> path(const Source& source, const locale& loc) it is myname(source), obtaining any needed codecvt facets from loc.  
  
 For template<class InIt\> path(InIt first, InIt last) it is myname(first, last).  
  
 For template<class InIt\> path(InIt first, InIt last, const locale& loc) it is myname(first, last), obtaining any needed codecvt facets from loc.  
  
## path::preferred_separator  
  

#Si _WIN32_C_LIB
constexpr estático value_type preferred_separator == L'\';
#Else / / se asume Posix
constexpr estático value_type preferred_separator == '/';
#endif / / ahora definido por el modelo de sistema de archivos

  
 The constant object gives the preferred character for separating path components, depending on the host operating system. Note that it is equally permissible in most contexts under Windows to use L'/' in its place.  
  
## path::relative_path  
  

ruta de acceso relative_path() const;

  
 Returns the relative path component of myname, specifically the suffix of myname after removing root_path().native() and any immediately subsequent redundant directory separators. The component may be empty.  
  
## path::remove_filename  
  

ruta de acceso de aspecto remove_filename();

  
## path::replace_extension  
  

ruta de acceso de aspecto replace_extension (const ruta aspecto newext = path());

  
 The member function first removes the suffix extension().native() from myname. Then if !newext.empty() && newext[0] != dot (where dot is *path(".").c_str()), then dot is appended to myname. Then newext is appended to myname.  
  
## path::replace_filename  
  

ruta de acceso de aspecto replace_filename (const ruta aspecto pval);

  
 The member function executes:  
  

remove_filename();

Esto / = pval; devolver (esto);

  
## path::root_directory  
  

ruta de acceso root_directory() const;

  
 Returns the root directory component of myname. The component may be empty.  
  
## path::root_name  
  

ruta de acceso root_name() const;

  
 Returns the root name component of myname. The component may be empty.  
  
## path::root_path  
  

ruta de acceso root_path() const;

  
 Returns the root path component of myname, specifically root_name() / root_directory. The component may be empty.  
  
## path::stem  
  

ruta de acceso stem() const;

  
 Returns the stem component of myname, specifically filename().native() with any trailing extension().native() removed. The component may be empty.  
  
## path::string  
  

plantilla<class Elem,></class Elem,>
clase de rasgos = char_traits,
clase Alloc = asignador>
basic_string<Elem, traits,="" alloc=""></Elem,>
cadena (const Alloc aspecto al = Alloc()) const;

STD cadena string() const;

  
 The first (template) member function converts the sequence stored in mypath the same way as:  
  
1.  string() for string<char, Traits, Alloc>()  
  
2.  wstring() for string<wchar_t, Traits, Alloc>()  
  
3.  u16string() for string<char16_t, Traits, Alloc>()  
  
4.  u32string() for string<char32_t, Traits, Alloc>()  
  
 The second member function converts the sequence stored in mypath to the encoding favored by the host system for a char sequence and returns it stored in an object of type string.  
  
## path::string_type  
  

TypeDef basic_string<value_type> string_type;</value_type>

  
 The type is a synonym for basic_string<value_type>.  
  
## path::swap  
  

noexcept void swap (ruta de acceso de aspecto derecha);

  
 Executes swap(mypath, right.mypath).  
  
## path::u16string  
  

STD u16string u16string() const;

  
 The member function converts the sequence stored in mypath to UTF-16 and returns it stored in an object of type u16string.  
  
## path::u32string  
  

STD u32string u32string() const;

  
 The member function converts the sequence stored in mypath to UTF-32 and returns it stored in an object of type u32string.  
  
## path::u8string  
  

STD cadena u8string() const;

  
 The member function converts the sequence stored in mypath to UTF-8 and returns it stored in an object of type u8string.  
  
## path::value_type  
  

#Si _WIN32_C_LIB
TypeDef wchar_t value_type;
#Else / / se asume Posix
TypeDef char value_type;
#endif / / ahora definido por el modelo de sistema de archivos

  
 The type describes the path elements favored by the host operating system.  
  
## path::wstring  
  

STD wstring wstring() const;

  
 Converts the sequence stored in mypath to the encoding favored by the host system for a wchar_t sequence and returns it stored in an object of type wstring.  
  
## Requirements  
 **Header:** filesystem  
  
 **Namespace:** std::tr2::sys  
  
## See Also  
 [Header Files Reference](../Topic/C++%20Standard%20Library%20Header%20Files.md)


Mostrar: