Classe path

La path classe archivia un oggetto di tipo string_type, chiamato myname qui ai fini dell'esposizione, adatto per l'uso come pathname. string_type è un sinonimo di basic_string<value_type>, dove value_type è un sinonimo di wchar_t in Windows o char in POSIX.

La path classe descritta di seguito è la classe C++17 std::filesystem::path nell'intestazione <filesystem> .

Per altre informazioni ed esempi di codice, vedere Esplorazione del file system.

Sintassi

class path;

Costruttori

Typedef

Enumerations

Funzioni membro

Operatori

Requisiti

Intestazione:<filesystem>

Spazio dei nomi:std::filesystem

path::append

Aggiunge la sequenza specificata a myname, convertita e inserendo un oggetto preferred_separator in base alle esigenze.

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

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

Parametri

source
Sequenza specificata.

first
Inizio della sequenza specificata.

last
Fine della sequenza specificata.

path::assign

myname Sostituisce con la sequenza specificata, convertita in base alle esigenze.

path& assign(string_type&& source);

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

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

Parametri

source
Sequenza specificata.

first
Inizio della sequenza specificata.

last
Fine della sequenza specificata.

path::begin

Restituisce un path::iterator oggetto che designa il primo elemento path nel pathname, se presente.

iterator begin() const;

path::c_str

Restituisce un puntatore al primo carattere in myname.

const value_type* c_str() const noexcept;

path::clear

myname.clear()Esegue .

void clear() noexcept;

path::compare

La prima funzione confronta gli elementi di questo percorso con pval. Le altre funzioni costruiscono un percorso dal relativo argomento e restituiscono il risultato del confronto con questo percorso.

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;

Parametri

pval
Percorso da confrontare.

str
Stringa da confrontare.

ptr
Puntatore da confrontare.

path::concat

Aggiunge la sequenza specificata a myname, convertita (ma non inserendo un separatore) in base alle esigenze.

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

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

Parametri

source
Sequenza specificata.

first
Inizio della sequenza specificata.

last
Fine della sequenza specificata.

path::const_iterator

Sinonimo di iterator.

typedef iterator const_iterator;

path::empty

Restituisce myname.empty().

bool empty() const noexcept;

path::end

Restituisce un iteratore di fine sequenza di tipo iterator.

iterator end() const;

path::extension

Restituisce il suffisso di filename().

path extension() const;

Osservazioni:

Restituisce il suffisso di filename() X in modo che:

Se X == path(".") || X == path("..") o se X non contiene punti, il suffisso è vuoto.

In caso contrario, il suffisso comincia con (e include) il punto all'estrema destra.

path::filename

Restituisce il componente filename di myname, in empty() ? path() : *--end()particolare . Il componente può essere vuoto.

path filename() const;

path::format

Specifica il formato pathname utilizzato per interpretare la sequenza di caratteri passata a un path costruttore.

enum format {
    auto_format,
    native_format,
    generic_format
};

Members

Osservazioni:

Poiché il formato nativo e il formato generico sono intercambiabili in Windows, l'implementazione Microsoft considera tutti e tre gli enumeratori uguali. Il format parametro viene fornito per la conformità e la portabilità standard. Per altre informazioni, vedere la specifica WG21 N4659 [fs.class.path].

path::generic_string

Restituisce this->string<Elem, Traits, Alloc>(al) con (in Windows) qualsiasi barra rovesciata convertita in una barra.

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

Restituisce u16string() con (in Windows) qualsiasi barra rovesciata convertita in una barra.

u16string generic_u16string() const;

path::generic_u32string

Restituisce u32string() con (in Windows) qualsiasi barra rovesciata convertita in una barra.

u32string generic_u32string() const;

path::generic_u8string

Restituisce u8string() con (in Windows) qualsiasi barra rovesciata convertita in una barra.

string generic_u8string() const;

path::generic_wstring

Restituisce wstring() con (in Windows) qualsiasi barra rovesciata convertita in una barra.

wstring generic_wstring() const;

path::has_extension

Restituisce !extension().empty().

bool has_extension() const;

path::has_filename

Restituisce !filename().empty().

bool has_filename() const;

path::has_parent_path

Restituisce !parent_path().empty().

bool has_parent_path() const;

path::has_relative_path

Restituisce !relative_path().empty().

bool has_relative_path() const;

path::has_root_directory

Restituisce !root_directory().empty().

bool has_root_directory() const;

path::has_root_name

Restituisce !root_name().empty().

bool has_root_name() const;

path::has_root_path

Restituisce !root_path().empty().

bool has_root_path() const;

path::has_stem

Restituisce !stem().empty().

bool has_stem() const;

path::is_absolute

Per Windows, la funzione restituisce has_root_name() && has_root_directory(). Per POSIX, la funzione restituisce has_root_directory().

bool is_absolute() const;

path::is_relative

Restituisce !is_absolute().

bool is_relative() const;

path::iterator

Iteratore costante bidirezionale che definisce i componenti del percorso di 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;
   // ...
   };

Osservazioni:

La classe descrive un iteratore costante bidirezionale che definisce i path componenti di myname nella sequenza:

1. nome radice, se presente

2. directory radice, se presente

3. gli elementi di directory rimanenti dell'elemento padre path, se presente, terminando con il nome file, se presente

Per pval un oggetto di tipo path:

1. path::iterator X = pval.begin() designa il primo path elemento nel pathname, se presente.

2. X == pval.end() è true quando X punta appena oltre la fine della sequenza di componenti.

3. *X restituisce una stringa che corrisponde al componente corrente

4. ++X definisce il componente successivo nella sequenza, se presente.

5. --X definisce il componente precedente nella sequenza, se presente.

6. La modifica myname invalida tutti gli iteratori che designano gli elementi in myname.

path::lexically_normal

Restituisce myname convertito in forma normale. La conversione è puramente lessicale: il file system non è accessibile.

path lexically_normal() const;

Osservazioni:

La normalizzazione comprime gli elementi ridondanti, ad . esempio e .. i separatori di directory. Ad esempio, path("a/./b/../c").lexically_normal() restituisce su a\c Windows. Un percorso vuoto si normalizza in un percorso vuoto; un percorso che riduce a nulla si normalizza in .. Per l'algoritmo di normalizzazione completo, vedere la specifica WG21 N4659 [fs.path.generic].

path::lexically_proximate

Restituisce il risultato di lexically_relative(base). Se tale risultato è un percorso vuoto, restituisce invece una copia di *this .

path lexically_proximate(const path& base) const;

Parametri

base
Percorso di base da raggiungere *this .

path::lexically_relative

Restituisce restituiti myname relativi a base, usando solo l'analisi lessicale (stringa). Il file system non è accessibile.

path lexically_relative(const path& base) const;

Parametri

base
Percorso di base da fare *this rispetto a .

Osservazioni:

Se root_name() != base.root_name()o se un percorso è assoluto e l'altro è relativo oppure se il percorso ha un nome file ma nessuna directory radice mentre la base non lo fa, restituisce un percorso vuoto. In caso contrario, determina il percorso relativo da base a trovando il primo elemento non corrispondente e generando .. per ogni elemento rimanente di base, seguito dagli elementi rimanenti di *this*this . Ad esempio, path("/a/d").lexically_relative("/a/b/c") restituisce ..\..\d. Per l'algoritmo completo, vedere la specifica WG21 N4659 [fs.path.gen].

path::make_preferred

Converte ogni separatore in un oggetto preferred_separator in base alle esigenze.

path& make_preferred();

path::native

Ottiene la rappresentazione di stringa nativa del percorso.

const string_type& native() const noexcept;

Osservazioni:

Il percorso è disponibile in un formato generico portabile (vedere generic_string()) o nel formato nativo del percorso. Questa funzione restituisce la stringa nativa. In un sistema POSIX il formato generico e il formato nativo sono gli stessi.

Nell'esempio seguente in esecuzione in Windows la stringa di percorso generica è c:/t/temp.txt e la stringa nativa è 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=

Sostituisce gli elementi del percorso con una copia di un altro percorso.

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

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

Parametri

right
Oggetto path copiato in path.

source
Il path di origine.

Osservazioni:

Il primo operatore membro copia right.myname in myname. Il secondo operatore membro passa right.myname a myname. Il terzo operatore membro passa source a myname. Il quarto operatore membro si comporta come *this = path(source).

path::operator+=

Varie concat espressioni.

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

Parametri

right
Percorso aggiunto.

str
Stringa aggiunta.

ptr
Puntatore aggiunto.

elem
Oggetto aggiunto value_type o Elem.

source
Origine aggiunta.

Osservazioni:

Le funzioni membro si comportano allo stesso modo di chiamare concat con l'argomento . Gli pathoverload , basic_string_viewstring_type, e con terminazione value_type* Null concatenano la sequenza di caratteri dell'argomento. Gli value_type overload e Elem concatenano un singolo carattere. L'overload basato su Source modelli concatena la sequenza di origine convertita.

path::operator/=

Varie append espressioni.

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

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

Parametri

right
Percorso aggiunto.

source
Origine aggiunta.

Osservazioni:

Le funzioni membro si comportano allo stesso modo delle corrispondenti espressioni riportate di seguito:

1. append(right);

2. append(source);

path::operator string_type

Restituisce myname.

operator string_type() const;

path::parent_path

Restituisce il componente del percorso padre di myname.

path parent_path() const;

Osservazioni:

Restituisce il componente percorso padre di myname, in particolare il prefisso di myname dopo la rimozione filename().native() e gli eventuali separatori di directory immediatamente precedenti. (Allo stesso modo, se begin() != end(), è la combinazione di tutti gli elementi nell'intervallo [begin(), --end()) applicando operator/=successivamente .) Il componente può essere vuoto.

path::path

Costruisce un oggetto path in vari modi.

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

Parametri

right
Percorso del quale il percorso costruito deve essere una copia.

source
Origine di cui il percorso costruito deve essere una copia.

fmt
Percorso format utilizzato per interpretare source o l'intervallo/firstlast. Di default è auto_format.

loc
Impostazioni locali specificate.

first
Posizione del primo elemento da copiare.

last
Posizione dell'ultimo elemento da copiare.

Osservazioni:

Tutti i costruttori sono costrutti myname in vari modi:

Perché path() è myname().

Perché path(const path& right) è myname(right.myname).

Perché path(path&& right) è myname(right.myname).

Perché path(string_type&& source, format fmt) è myname(move(source)).

Perché template<class Source> path(const Source& source, format fmt) è myname(source).

Per template<class Source> path(const Source& source, const locale& loc, format fmt) è myname(source), ottenendo tutti i facet necessari codecvt da loc.

Perché template<class InIt> path(InIt first, InIt last, format fmt) è myname(first, last).

Per template<class InIt> path(InIt first, InIt last, const locale& loc, format fmt) è myname(first, last), ottenendo tutti i facet necessari codecvt da loc.

Il fmt parametro seleziona il formato pathname. In Windows, i formati nativi e generici sono intercambiabili, pertanto l'implementazione Microsoft ignora fmt.

path::preferred_separator

L'oggetto costante fornisce il carattere preferito per la separazione dei componenti path, a seconda 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

Osservazioni:

È altrettanto consentito nella maggior parte dei contesti in Windows usare L'/' al suo posto.

path::relative_path

Restituisce il componente percorso relativo di myname.

path relative_path() const;

Osservazioni:

Restituisce il componente relativo del percorso di myname, in particolare il suffisso di myname dopo la rimozione root_path().native() e gli eventuali separatori di directory immediatamente ridondanti successivi. Il componente può essere vuoto.

path::remove_filename

Rimuove il nome file.

path& remove_filename();

path::replace_extension

Sostituisce l'estensione di myname.

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

Parametri

newext
Nuova estensione.

Osservazioni:

Rimuove prima di tutto il suffisso extension().native() da myname. Quindi, se (dove !newext.empty() && newext[0] != dot punto è ), il punto viene aggiunto a *path(".").c_str().myname Viene quindi newext aggiunto a myname.

path::replace_filename

Sostituisce il nome file.

path& replace_filename(const path& pval);

Parametri

pval
Percorso del nome file.

Osservazioni:

La funzione membro esegue:

remove_filename();

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

path::root_directory

Restituisce il componente della directory radice di myname.

path root_directory() const;

Osservazioni:

Il componente può essere vuoto.

path::root_name

Restituisce il componente del nome radice di myname.

path root_name() const;

Osservazioni:

Il componente può essere vuoto.

path::root_path

Restituisce il componente del percorso radice di myname.

path root_path() const;

Osservazioni:

Restituisce il componente del percorso radice di myname, in particolareroot_name() / root_directory . Il componente può essere vuoto.

path::stem

Restituisce il stem componente di myname.

path stem() const;

Osservazioni:

Restituisce il stem componente di myname, in particolare filename().native() con qualsiasi elemento finale extension().native() rimosso. Il componente può essere vuoto.

path::string

Converte la sequenza archiviata in 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;

Osservazioni:

La prima funzione membro (modello) converte la sequenza archiviata nello myname stesso modo di:

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

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

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

4. u32string() per string<char32_t, Traits, Alloc>()

La seconda funzione membro converte la sequenza archiviata nella myname codifica preferita dal sistema host per una char sequenza e la restituisce archiviata in un oggetto di tipo string.

path::string_type

Il tipo è sinonimo di basic_string<value_type>.

typedef basic_string<value_type> string_type;

path::swap

swap(myname, right.myname)Esegue .

void swap(path& right) noexcept;

path::u16string

Converte la sequenza archiviata in myname UTF-16 e la restituisce archiviata in un oggetto di tipo u16string.

u16string u16string() const;

path::u32string

Converte la sequenza archiviata in myname UTF-32 e la restituisce archiviata in un oggetto di tipo u32string.

u32string u32string() const;

path::u8string

Converte la sequenza archiviata in myname UTF-8 e la restituisce archiviata in un oggetto di tipo u8string.

string u8string() const;

path::value_type

Il tipo descrive gli path elementi favoriti dal 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

Converte la sequenza archiviata in myname nella codifica preferita dal sistema host per una wchar_t sequenza e la restituisce archiviata in un oggetto di tipo wstring.

wstring wstring() const;

Vedi anche

<filesystem>
Riferimento file di intestazione