Classe directory_iterator

Descrive un iteratore di input sequenziato attraverso i nomi file in una directory. Per un iteratore X, l'espressione *X restituisce un oggetto della classe directory_entry che esegue il wrapping del nome file e qualsiasi elemento noto sul relativo stato.

La classe archivia un oggetto di tipo path, chiamato mydir qui ai fini dell'esposizione, che rappresenta il nome della directory da sequenziare e un oggetto di tipo directory_entry denominato myentry qui, che rappresenta il nome file corrente nella sequenza di directory. Un oggetto costruito predefinito di tipo directory_entry ha un percorso vuoto mydir e rappresenta l'iteratore di fine sequenza.

Ad esempio, data la directory abc con voci def e ghi, il codice:

for (directory_iterator next(path("abc")), end; next != end; ++next) visit(next->path());

chiama visit con gli path("abc/def") argomenti e path("abc/ghi").

Per altre informazioni ed esempi di codice, vedere File System Navigation (C++) (Esplorazione del file system (C++)).

Sintassi

class directory_iterator;

Costruttori

Costruttore	Descrizione
directory_iterator	Costruisce un iteratore di input che sequenzia i nomi file in una directory.

Funzioni membro

Funzione membro	Descrizione
increment	Tenta di passare al nome file successivo nella directory.

Operatori

Operatore	Descrizione
operator!=	Restituisce !(*this == right).
operator=	Gli operatori di assegnazione membro impostati come predefiniti si comportano come previsto.
operator==	Restituisce true solo se e *thisright sono iteratori di fine sequenza o entrambi non sono iteratori di fine sequenza.
operator*	Restituisce myentry.
operator->	Restituisce &**this.
operator++	Chiama increment(), quindi restituisce *thiso crea una copia dell'oggetto , chiama increment(), quindi restituisce la copia.

Requisiti

Intestazione:<filesystem>

Spazio dei nomi:std::filesystem

directory_iterator::directory_iterator

Il primo costruttore produce un iteratore di fine sequenza. I costruttori che accettano un pval argomento lo archivia in mydir, quindi tentano di aprire e leggere mydir come directory. In caso di esito positivo, archiviano il primo nome file nella directory in myentry; in caso contrario, producono un iteratore di fine sequenza. Gli overload che accettano un options argomento controllano la modalità di enumerazione della directory. Gli overload che accettano un ec argomento segnalano errori anziché ec generare un'eccezione. I costruttori di copia e spostamento si comportano come previsto.

directory_iterator() noexcept;
explicit directory_iterator(const path& pval);
directory_iterator(const path& pval, directory_options options);
directory_iterator(const path& pval, error_code& ec) noexcept;
directory_iterator(const path& pval, directory_options options, error_code& ec) noexcept;
directory_iterator(const directory_iterator&) = default;
directory_iterator(directory_iterator&&) noexcept = default;

Parametri

pval
Percorso del nome file archiviato.

options
Valore directory_options che controlla la modalità di enumerazione della directory. Il valore predefinito è directory_options::none.

ec
Codice di errore di stato.

directory_iterator
Oggetto archiviato.

directory_iterator::increment

La funzione prova a avanzare al nome file successivo nella directory. In caso di esito positivo, archivia il nome file in myentry; in caso contrario, produce un iteratore di fine sequenza.

directory_iterator& increment(error_code& ec);

Parametri

ec
Codice di errore di stato.

directory_iterator::operator!=

L'operatore membro restituisce !(*this == right).

bool operator!=(const directory_iterator& right) const;

Parametri

right
Oggetto directory_iterator confrontato con .directory_iterator

directory_iterator::operator=

Gli operatori di assegnazione membro impostati come predefiniti si comportano come previsto.

directory_iterator& operator=(const directory_iterator&) = default;
directory_iterator& operator=(directory_iterator&&) noexcept = default;

Parametri

right
Oggetto directory_iterator copiato in directory_iterator.

directory_iterator::operator==

L'operatore membro restituisce true solo se *this e right sono iteratori di fine sequenza o entrambi non sono iteratori di fine sequenza.

bool operator==(const directory_iterator& right) const;

Parametri

right
Il directory_iterator confrontato con .directory_iterator

directory_iterator::operator*

L'operatore membro restituisce myentry.

const directory_entry& operator*() const;

directory_iterator::operator->

La funzione membro restituisce&**this.

const directory_entry * operator->() const;

directory_iterator::operator++

La prima funzione membro chiama increment(), quindi restituisce *this. La seconda funzione membro crea una copia dell'oggetto, chiama increment(), quindi restituisce la copia.

directory_iterator& operator++();
directory_iterator operator++(int);

Parametri

int
Argomento fittizio. Si tratta di una convenzione C++ usata solo per distinguere l'operatore di incremento del prefisso dall'operatore di incremento del prefisso. Lo standard C++ richiede che il formato del prefisso assuma un parametro int fittizio.

Vedi anche

<filesystem>
Riferimento file di intestazione
Esplorazione del file system (C++)