Archivo de encabezado de la biblioteca estándar <filesystem>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnósticos <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <type_traits> (C++11) <ratio> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numéricos <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/Salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo para concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

See More

Este archivo de encabezado es parte de la biblioteca de soporte de sistema de archivos.

Definido en el espacio de nombres filesystem
Clases
path (C++17)	Representa una ruta de acceso. (clase)
filesystem_error (C++17)	Una excepción lanzada cuando hay errores en el sistema de archivos. (clase)
directory_entry (C++17)	Una entrada de directorio. (clase)
directory_iterator (C++17)	Un iterador al contenido del directorio. (clase)
recursive_directory_iterator (C++17)	Un iterador al contenido de un directorio y sus subdirectorios. (clase)
file_status (C++17)	Representa el tipo y permisos de archivo. (clase)
space_info (C++17)	Información sobre el espacio libre y disponible en el sistema de archivos. (clase)
file_type (C++17)	El tipo de un archivo. (enum)
perms (C++17)	Identifica los permisos del sistema de archivos. (enum)
perm_options (C++17)	Especifica la semántica de las operaciones de permisos. (enum)
copy_options (C++17)	Especifica la semántica de las operaciones de copia. (enum)
directory_options (C++17)	Opciones para iterar sobre el contenido de un directorio. (enum)
file_time_type (C++17)	Representa los valores de tiempo de un archivo. (typedef)
Funciones
u8path (C++17)(en desuso en C++20)	Crea una ruta de acceso a partir de una fuente codificada en UTF-8. (función)
absolute (C++17)	Compone una ruta de acceso absoluta. (función)
canonicalweakly_canonical (C++17)	Compone una ruta de acceso canónica. (función)
relativeproximate (C++17)	Compone una ruta de acceso relativa. (función)
copy (C++17)	Copia archivos o directorios. (función)
copy_file (C++17)	Copia el contenido de un archivo. (función)
copy_symlink (C++17)	Copia un enlace simbólico. (función)
create_directorycreate_directories (C++17)(C++17)	Crea un directorio nuevo. (función)
create_hard_link (C++17)	Crea un enlace físico. (función)
create_symlinkcreate_directory_symlink (C++17)(C++17)	Crea un enlace simbólico. (función)
current_path (C++17)	Devuelve o establece el directorio de trabajo actual. (función)
exists (C++17)	Verifica si una ruta de acceso se refiere a un objeto existente del sistema de archivos. (función)
equivalent (C++17)	Verifica si dos rutas de acceso se refieren al mismo objeto de sistema de archivos. (función)
file_size (C++17)	Devuelve el tamaño de un archivo. (función)
hard_link_count (C++17)	Devuelve el número de enlaces físicos que se refieren a un archivo específico. (función)
last_write_time (C++17)	Capta o establece el tiempo de la última modificación de datos. (función)
permissions (C++17)	Modifica los permisos de acceso a archivo. (función)
read_symlink (C++17)	Obtiene el objetivo de un enlace simbólico. (función)
removeremove_all (C++17)(C++17)	Remueve un archivo o directorio vacío. Remueve un archivo o directorio y todo su contenido recursivamente. (función)
rename (C++17)	Mueve o renombra un archivo o directorio. (función)
resize_file (C++17)	Cambia el tamaño de un archivo regular por truncamiento o relleno con ceros. (función)
space (C++17)	Determina el espacio libre disponible en el sistema de archivos. (función)
statussymlink_status (C++17)(C++17)	Determina los atributos de archivo. Determina los atributos de archivo, verificando el objetivo del enlace simbólico. (función)
temp_directory_path (C++17)	Devuelve un directorio adecuado para archivos temporales. (función)
Tipos de archivo
is_block_file (C++17)	Verifica si una ruta de acceso dada se refiere a un dispositivo de bloques. (función)
is_character_file (C++17)	Verifica si la ruta de acceso dada se refiere a un dispositivo de caracteres. (función)
is_directory (C++17)	Verifica si la ruta de acceso dada se refiere a un directorio. (función)
is_empty (C++17)	Verifica si la ruta de acceso dada se refiere a un archivo o directorio vacío. (función)
is_fifo (C++17)	Verifica si la ruta de acceso dada se refiere a una tubería con nombre (named pipe). (función)
is_other (C++17)	Verifica si el argumento se refiere a "otro" tipo de archivo. (función)
is_regular_file (C++17)	Verifica si el argumento se refiere a un archivo regular. (función)
is_socket (C++17)	Verifica si el argumento se refiere a un socket de comunicación interproceso con nombre. (función)
is_symlink (C++17)	Verifica si el argumento se refiere a un enlace simbólico. (función)
status_known (C++17)	Verifica si se conoce el estado de archivo. (función)

Sinopsis

namespace std::filesystem {
  // rutas de acceso
  class path;
  // funciones no miembro de rutas de acceso
  void swap(path& lhs, path& rhs) noexcept;
  size_t hash_value(const path& p) noexcept;
  bool operator==(const path& lhs, const path& rhs) noexcept;
  bool operator!=(const path& lhs, const path& rhs) noexcept;
  bool operator< (const path& lhs, const path& rhs) noexcept;
  bool operator<=(const path& lhs, const path& rhs) noexcept;
  bool operator> (const path& lhs, const path& rhs) noexcept;
  bool operator>=(const path& lhs, const path& rhs) noexcept;
  path operator/ (const path& lhs, const path& rhs);
  // insertador y extractor de ruta de acceso
  template <typename charT, typename traits>
  basic_ostream<charT, traits>&
    operator<<(basic_ostream<charT, traits>& os, const path& p);
  template <typename charT, typename traits>
  basic_istream<charT, traits>&
    operator>>(basic_istream<charT, traits>& is, path& p);
  // funciones fábrica de rutas de acceso
  template <typename Source>
  path u8path(const Source& source);
  template <typename InputIterator>
  path u8path(InputIterator first, InputIterator last);
  // errores del sistema de archivos
  class filesystem_error;
  // entradas de directorio
  class directory_entry;
  // iteradores de directorio
  class directory_iterator;
  // acceso a rango para iteradores de directorio
  directory_iterator begin(directory_iterator iter) noexcept;
  directory_iterator end(const directory_iterator&) noexcept;
  // iteradores de directorio recursivos
  class recursive_directory_iterator;
  // acceso a rango para iteradores de directorio recursivos
  recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
  recursive_directory_iterator end(const recursive_directory_iterator&) noexcept;
  // estatus de archivo
  class file_status;
  struct space_info {
    uintmax_t capacity;
    uintmax_t free;
    uintmax_t available;
  };
  // enumeraciones
  enum class file_type;
  enum class perms;
  enum class perm_options;
  enum class copy_options;
  enum class directory_options;
  using file_time_type = chrono::time_point<trivial-clock >;
  // operaciones de sistema de archivos
  path absolute(const path& p, const path& base = current_path());
  path canonical(const path& p, const path& base = current_path());
  path canonical(const path& p, error_code& ec);
  path canonical(const path& p, const path& base, error_code& ec);
  void copy(const path& from, const path& to);
  void copy(const path& from, const path& to, error_code& ec) noexcept;
  void copy(const path& from, const path& to, copy_options options);
  void copy(const path& from, const path& to, copy_options options,
            error_code& ec) noexcept;
  bool copy_file(const path& from, const path& to);
  bool copy_file(const path& from, const path& to, error_code& ec) noexcept;
  bool copy_file(const path& from, const path& to, copy_options option);
  bool copy_file(const path& from, const path& to, copy_options option,
                 error_code& ec) noexcept;
  void copy_symlink(const path& existing_symlink, const path& new_symlink);
  void copy_symlink(const path& existing_symlink, const path& new_symlink,
                    error_code& ec) noexcept;
  bool create_directories(const path& p);
  bool create_directories(const path& p, error_code& ec) noexcept;
  bool create_directory(const path& p);
  bool create_directory(const path& p, error_code& ec) noexcept;
  bool create_directory(const path& p, const path& attributes);
  bool create_directory(const path& p, const path& attributes,
                        error_code& ec) noexcept;
  void create_directory_symlink(const path& to, const path& new_symlink);
  void create_directory_symlink(const path& to, const path& new_symlink,
                                error_code& ec) noexcept;
  void create_hard_link(const path& to, const path& new_hard_link);
  void create_hard_link(const path& to, const path& new_hard_link,
                        error_code& ec) noexcept;
  void create_symlink(const path& to, const path& new_symlink);
  void create_symlink(const path& to, const path& new_symlink,
                      error_code& ec) noexcept;
  path current_path();
  path current_path(error_code& ec);
  void current_path(const path& p);
  void current_path(const path& p, error_code& ec) noexcept;
  bool exists(file_status s) noexcept;
  bool exists(const path& p);
  bool exists(const path& p, error_code& ec) noexcept;
  bool equivalent(const path& p1, const path& p2);
  bool equivalent(const path& p1, const path& p2, error_code& ec) noexcept;
  uintmax_t file_size(const path& p);
  uintmax_t file_size(const path& p, error_code& ec) noexcept;
  uintmax_t hard_link_count(const path& p);
  uintmax_t hard_link_count(const path& p, error_code& ec) noexcept;
  bool is_block_file(file_status s) noexcept;
  bool is_block_file(const path& p);
  bool is_block_file(const path& p, error_code& ec) noexcept;
  bool is_character_file(file_status s) noexcept;
  bool is_character_file(const path& p);
  bool is_character_file(const path& p, error_code& ec) noexcept;
  bool is_directory(file_status s) noexcept;
  bool is_directory(const path& p);
  bool is_directory(const path& p, error_code& ec) noexcept;
  bool is_empty(const path& p);
  bool is_empty(const path& p, error_code& ec) noexcept;
  bool is_fifo(file_status s) noexcept;
  bool is_fifo(const path& p);
  bool is_fifo(const path& p, error_code& ec) noexcept;
  bool is_other(file_status s) noexcept;
  bool is_other(const path& p);
  bool is_other(const path& p, error_code& ec) noexcept;
  bool is_regular_file(file_status s) noexcept;
  bool is_regular_file(const path& p);
  bool is_regular_file(const path& p, error_code& ec) noexcept;
  bool is_socket(file_status s) noexcept;
  bool is_socket(const path& p);
  bool is_socket(const path& p, error_code& ec) noexcept;
  bool is_symlink(file_status s) noexcept;
  bool is_symlink(const path& p);
  bool is_symlink(const path& p, error_code& ec) noexcept;
  file_time_type last_write_time(const path& p);
  file_time_type last_write_time(const path& p, error_code& ec) noexcept;
  void last_write_time(const path& p, file_time_type new_time);
  void last_write_time(const path& p, file_time_type new_time,
                       error_code& ec) noexcept;
  void permissions(const path& p, perms prms,
                   perm_options opts = perm_options::replace);
  void permissions(const path& p, perms prms, error_code& ec) noexcept;
  void permissions(const path& p, perms prms,
                   perm_options opts, error_code& ec) noexcept;
  path proximate(const path& p, error_code& ec);
  path proximate(const path& p, const path& base = current_path());
  path proximate(const path& p, const path& base, error_code& ec);
  path read_symlink(const path& p);
  path read_symlink(const path& p, error_code& ec);
  path relative(const path& p, error_code& ec);
  path relative(const path& p, const path& base = current_path());
  path relative(const path& p, const path& base, error_code& ec);
  bool remove(const path& p);
  bool remove(const path& p, error_code& ec) noexcept;
  uintmax_t remove_all(const path& p);
  uintmax_t remove_all(const path& p, error_code& ec) noexcept;
  void rename(const path& from, const path& to);
  void rename(const path& from, const path& to, error_code& ec) noexcept;
  void resize_file(const path& p, uintmax_t size);
  void resize_file(const path& p, uintmax_t size, error_code& ec) noexcept;
  space_info space(const path& p);
  space_info space(const path& p, error_code& ec) noexcept;
  file_status status(const path& p);
  file_status status(const path& p, error_code& ec) noexcept;
  bool status_known(file_status s) noexcept;
  file_status symlink_status(const path& p);
  file_status symlink_status(const path& p, error_code& ec) noexcept;
  path temp_directory_path();
  path temp_directory_path(error_code& ec);
  path weakly_canonical(const path& p);
  path weakly_canonical(const path& p, error_code& ec);
}

Clase std::filesystem::path

class path {
public:
  using value_type = /*véase definición*/ ;
  using string_type = basic_string<value_type>;
  static constexpr value_type preferred_separator = /*véase definición*/ ;
  // enumeraciones
  enum format {
    native_format,
    generic_format,
    auto_format
  };
  // constructores y destructor
  path() noexcept;
  path(const path& p);
  path(path&& p) noexcept;
  path(string_type&& source, format = auto_format);
  template <typename Source>
  path(const Source& source, format = auto_format);
  template <typename InputIterator>
  path(InputIterator first, InputIterator last, format = auto_format);
  template <typename Source>
  path(const Source& source, const locale& loc, format = auto_format);
  template <typename InputIterator>
  path(InputIterator first, InputIterator last,
       const locale& loc, format = auto_format);
  ~path();
  // asignaciones
  path& operator=(const path& p);
  path& operator=(path&& p) noexcept;
  path& operator=(string_type&& source);
  path& assign(string_type&& source);
  template <typename Source>
  path& operator=(const Source& source);
  template <typename Source>
  path& assign(const Source& source)
  template <typename InputIterator>
  path& assign(InputIterator first, InputIterator last);
  // añadiduras/agregaciones
  path& operator/=(const path& p);
  template <typename Source>
  path& operator/=(const Source& source);
  template <typename Source>
  path& append(const Source& source);
  template <typename InputIterator>
  path& append(InputIterator first, InputIterator last);
  // concatenación
  path& operator+=(const path& x);
  path& operator+=(const string_type& x);
  path& operator+=(basic_string_view<value_type> x);
  path& operator+=(const value_type* x);
  path& operator+=(value_type x);
  template <typename Source>
  path& operator+=(const Source& x);
  template <typename EcharT>
  path& operator+=(EcharT x);
  template <typename Source>
  path& concat(const Source& x);
  template <typename InputIterator>
  path& concat(InputIterator first, InputIterator last);
  // modificadores
  void clear() noexcept;
  path& make_preferred();
  path& remove_filename();
  path& replace_filename(const path& replacement);
  path& replace_extension(const path& replacement = path());
  void swap(path& rhs) noexcept;
  // observadores de formato nativo
  const string_type& native() const noexcept;
  const value_type* c_str() const noexcept;
  operator string_type() const;
  template <typename EcharT, typename traits = char_traits<EcharT>,
            typename Allocator = allocator<EcharT>>
  basic_string<EcharT, traits, Allocator>
    string(const Allocator& a = Allocator()) const;
  std::string string() const;
  std::wstring wstring() const;
  std::string u8string() const;
  std::u16string u16string() const;
  std::u32string u32string() const;
  // observadores de formato genéricos
  template <typename EcharT, typename traits = char_traits<EcharT>,
            typename Allocator = allocator<EcharT>>
  basic_string<EcharT, traits, Allocator>
    generic_string(const Allocator& a = Allocator()) const;
  std::string generic_string() const;
  std::wstring generic_wstring() const;
  std::string generic_u8string() const;
  std::u16string generic_u16string() const;
  std::u32string generic_u32string() const;
  // comparar
  int compare(const path& p) const noexcept;
  int compare(const string_type& s) const;
  int compare(basic_string_view<value_type> s) const;
  int compare(const value_type* s) const;
  // descomposición
  path root_name() const;
  path root_directory() const;
  path root_path() const;
  path relative_path() const;
  path parent_path() const;
  path filename() const;
  path stem() const;
  path extension() const;
  // consulta
  bool empty() const noexcept;
  bool has_root_name() const;
  bool has_root_directory() const;
  bool has_root_path() const;
  bool has_relative_path() const;
  bool has_parent_path() const;
  bool has_filename() const;
  bool has_stem() const;
  bool has_extension() const;
  bool is_absolute() const;
  bool is_relative() const;
  // generación
  path lexically_normal() const;
  path lexically_relative(const path& base) const;
  path lexically_proximate(const path& base) const;
  // iteradores
  class iterator;
  using const_iterator = iterator;
  iterator begin() const;
  iterator end() const;
private:
  string_type pathstring; // solo exposición
};

Clase std::filesystem::filesystem_error

class filesystem_error : public system_error {
public:
  filesystem_error(const string& what_arg, error_code ec);
  filesystem_error(const string& what_arg,
                   const path& p1, error_code ec);
  filesystem_error(const string& what_arg,
                   const path& p1, const path& p2, error_code ec);
  const path& path1() const noexcept;
  const path& path2() const noexcept;
  const char* what() const noexcept override;
};

Clase std::filesystem::file_status

class file_status {
public:
  // constructores y destructor
  explicit file_status(file_type ft = file_type::none,
                       perms prms = perms::unknown) noexcept;
  file_status(const file_status&) noexcept = default;
  file_status(file_status&&) noexcept = default;
  ~file_status();
  // asignaciones:
  file_status& operator=(const file_status&) noexcept = default;
  file_status& operator=(file_status&&) noexcept = default;
  // modificadores
  void type(file_type ft) noexcept;
  void permissions(perms prms) noexcept;
  // observadores
  file_type type() const noexcept;
  perms permissions() const noexcept;
};

Clase std::directory_entry

class directory_entry {
public:
  // constructores y destructor
  explicit directory_entry(const path& p);
  directory_entry() noexcept = default;
  directory_entry(const directory_entry&) = default;
  directory_entry(directory_entry&&) noexcept = default;
  ~directory_entry();
  // asignaciones:
  directory_entry& operator=(const directory_entry&) = default;
  directory_entry& operator=(directory_entry&&) noexcept = default;
  // modificadores
  void assign(const path& p);
  void replace_filename(const path& p);
  // observadores
  const path& path() const noexcept;
  operator const path&() const noexcept;
  file_status status() const;
  file_status status(error_code& ec) const noexcept;
  file_status symlink_status() const;
  file_status symlink_status(error_code& ec) const noexcept;
  bool operator< (const directory_entry& rhs) const noexcept;
  bool operator==(const directory_entry& rhs) const noexcept;
  bool operator!=(const directory_entry& rhs) const noexcept;
  bool operator<=(const directory_entry& rhs) const noexcept;
  bool operator> (const directory_entry& rhs) const noexcept;
  bool operator>=(const directory_entry& rhs) const noexcept;
private:
  path pathobject; // solo exposición
};

Clase std::filesystem::directory_iterator

class directory_iterator {
public:
  using iterator_category = input_iterator_tag;
  using value_type = directory_entry;
  using difference_type = ptrdiff_t;
  using pointer = const directory_entry*;
  using reference = const directory_entry&;
  // funciones miembro
  directory_iterator() noexcept;
  explicit directory_iterator(const path& p);
  directory_iterator(const path& p, directory_options options);
  directory_iterator(const path& p, error_code& ec) noexcept;
  directory_iterator(const path& p, directory_options options,
                     error_code& ec) noexcept;
  directory_iterator(const directory_iterator& rhs);
  directory_iterator(directory_iterator&& rhs) noexcept;
  ~directory_iterator();
  directory_iterator& operator=(const directory_iterator& rhs);
  directory_iterator& operator=(directory_iterator&& rhs) noexcept;
  const directory_entry& operator*() const;
  const directory_entry* operator->() const;
  directory_iterator& operator++();
  directory_iterator& increment(error_code& ec) noexcept;
  // otros miembros requeridos por iteradores de entrada
};

Clase std::filesystem::recursive_directory_iterator

class recursive_directory_iterator {
public:
  using iterator_category = input_iterator_tag;
  using value_type = directory_entry;
  using difference_type = ptrdiff_t;
  using pointer = const directory_entry*;
  using reference = const directory_entry&;
  // constructores y destructor
  recursive_directory_iterator() noexcept;
  explicit recursive_directory_iterator(const path& p);
  recursive_directory_iterator(const path& p, directory_options options);
  recursive_directory_iterator(const path& p, directory_options options,
                               error_code& ec) noexcept;
  recursive_directory_iterator(const path& p, error_code& ec) noexcept;
  recursive_directory_iterator(const recursive_directory_iterator& rhs);
  recursive_directory_iterator(recursive_directory_iterator&& rhs) noexcept;
  ~recursive_directory_iterator();
  // observadores
  directory_options options() const;
  int depth() const;
  bool recursion_pending() const;
  const directory_entry& operator*() const;
  const directory_entry* operator->() const;
  // modificadores
  recursive_directory_iterator&
  operator=(const recursive_directory_iterator& rhs);
  recursive_directory_iterator&
  operator=(recursive_directory_iterator&& rhs) noexcept;
  recursive_directory_iterator& operator++();
  recursive_directory_iterator& increment(error_code& ec) noexcept;
  void pop();
  void pop(error_code& ec);
  void disable_recursion_pending();
  // otros miembros requeridos por iteradores de entrada
};