Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | header
 
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
 

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

Definido en el espacio de nombres filesystem

Contenido

Clases

(C++17)
 Representa una ruta de acceso.
(clase) [editar]
(C++17)
 Una excepción lanzada cuando hay errores en el sistema de archivos.
(clase) [editar]
(C++17)
 Una entrada de directorio.
(clase) [editar]
(C++17)
 Un iterador al contenido del directorio.
(clase) [editar]
(C++17)
 Un iterador al contenido de un directorio y sus subdirectorios.
(clase) [editar]
(C++17)
 Representa el tipo y permisos de archivo.
(clase) [editar]
(C++17)
 Información sobre el espacio libre y disponible en el sistema de archivos.
(clase) [editar]
(C++17)
 El tipo de un archivo.
(enum) [editar]
(C++17)
 Identifica los permisos del sistema de archivos.
(enum) [editar]
(C++17)
 Especifica la semántica de las operaciones de permisos.
(enum) [editar]
(C++17)
 Especifica la semántica de las operaciones de copia.
(enum) [editar]
(C++17)
 Opciones para iterar sobre el contenido de un directorio.
(enum) [editar]
(C++17)
 Representa los valores de tiempo de un archivo.
(typedef) [editar]

Funciones

(C++17)(en desuso en C++20)
 Crea una ruta de acceso a partir de una fuente codificada en UTF-8.
(función) [editar]
(C++17)
 Compone una ruta de acceso absoluta.
(función) [editar]
(C++17)
 Compone una ruta de acceso canónica.
(función) [editar]
(C++17)
 Compone una ruta de acceso relativa.
(función) [editar]
(C++17)
 Copia archivos o directorios.
(función) [editar]
(C++17)
 Copia el contenido de un archivo.
(función) [editar]
(C++17)
 Copia un enlace simbólico.
(función) [editar]
(C++17)(C++17)
 Crea un directorio nuevo.
(función) [editar]
(C++17)
 Crea un enlace físico.
(función) [editar]
(C++17)(C++17)
 Crea un enlace simbólico.
(función) [editar]
(C++17)
 Devuelve o establece el directorio de trabajo actual.
(función) [editar]
(C++17)
 Verifica si una ruta de acceso se refiere a un objeto existente del sistema de archivos.
(función) [editar]
(C++17)
 Verifica si dos rutas de acceso se refieren al mismo objeto de sistema de archivos.
(función) [editar]
(C++17)
 Devuelve el tamaño de un archivo.
(función) [editar]
(C++17)
 Devuelve el número de enlaces físicos que se refieren a un archivo específico.
(función) [editar]
(C++17)
 Capta o establece el tiempo de la última modificación de datos.
(función) [editar]
(C++17)
 Modifica los permisos de acceso a archivo.
(función) [editar]
(C++17)
 Obtiene el objetivo de un enlace simbólico.
(función) [editar]
(C++17)(C++17)
 Remueve un archivo o directorio vacío.
Remueve un archivo o directorio y todo su contenido recursivamente.
(función) [editar]
(C++17)
 Mueve o renombra un archivo o directorio.
(función) [editar]
(C++17)
 Cambia el tamaño de un archivo regular por truncamiento o relleno con ceros.
(función) [editar]
(C++17)
 Determina el espacio libre disponible en el sistema de archivos.
(función) [editar]
(C++17)(C++17)
 Determina los atributos de archivo.
Determina los atributos de archivo, verificando el objetivo del enlace simbólico.
(función) [editar]
(C++17)
 Devuelve un directorio adecuado para archivos temporales.
(función) [editar]
Tipos de archivo
(C++17)
 Verifica si una ruta de acceso dada se refiere a un dispositivo de bloques.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a un dispositivo de caracteres.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a un directorio.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a un archivo o directorio vacío.
(función) [editar]
(C++17)
 Verifica si la ruta de acceso dada se refiere a una tubería con nombre (named pipe).
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a "otro" tipo de archivo.
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a un archivo regular.
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a un socket de comunicación interproceso con nombre.
(función) [editar]
(C++17)
 Verifica si el argumento se refiere a un enlace simbólico.
(función) [editar]
(C++17)
 Verifica si se conoce el estado de archivo.
(función) [editar]

[editar] 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);
}

[editar] 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
};

[editar] 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;
};

[editar] 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;
};

[editar] 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
};

[editar] 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
};

[editar] 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
};
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/filesystem&oldid=34353»