предпочтительный разделитель:
             Зависимый от операционной системы разделитель каталогов. Может быть синонимом<"/">.

Directory-separator:
                                                &

namespace boost
{
  namespace filesystem
  {
    class path;
    
    bool lexicographical_compare(path::iterator first1, path::iterator last1,
      path::iterator first2, path::iterator last2);
    void swap(path& lhs, path& rhs);
    std::size_t hash_value(const path& p);
    bool operator==(const path& lhs, const path& rhs);
    bool operator!=(const path& lhs, const path& rhs);
    bool operator< (const path& lhs, const path& rhs);
    bool operator<=(const path& lhs, const path& rhs);
    bool operator> (const path& lhs, const path& rhs);
    bool operator>=(const path& lhs, const path& rhs);
    path operator/ (const path& lhs, const path& rhs);
    
    std::ostream&  operator<<( std::ostream& os, const path& p );
    std::wostream& operator<<( std::wostream& os, const path& p );
    std::istream&  operator>>( std::istream& is, path& p );
    std::wistream& operator>>( std::wistream& is, path& p )
    class filesystem_error;      
    class directory_entry;
    class directory_iterator;
    // enable c++11 range-based for statements
    const directory_iterator& begin(const directory_iterator& iter);
    directory_iterator end(const directory_iterator&);
    // enable BOOST_FOREACH
    directory_iterator& range_begin(directory_iterator& iter);
    directory_iterator range_begin(const directory_iterator& iter);
    directory_iterator range_end(const directory_iterator&);
    class recursive_directory_iterator;
    // enable c++11 range-based for statements
    const recursive_directory_iterator&
      begin(const recursive_directory_iterator& iter);
    recursive_directory_iterator
      end(const recursive_directory_iterator&);
    // enable BOOST_FOREACH
    recursive_directory_iterator&
      range_begin(recursive_directory_iterator& iter);
    recursive_directory_iterator
      range_begin(const recursive_directory_iterator& iter);
    recursive_directory_iterator
      range_end(const recursive_directory_iterator&);
    enum file_type
    {
      status_error, file_not_found, regular_file, directory_file,
      symlink_file, block_file, character_file, fifo_file, socket_file,
      type_unknown
    };
    enum perms
    {
      no_perms,
      owner_read, owner_write, owner_exe, owner_all,
      group_read, group_write, group_exe, group_all,
      others_read, others_write, others_exe, others_all, all_all,
      set_uid_on_exe, set_gid_on_exe, sticky_bit,
      perms_mask, perms_not_known,
      add_perms, remove_perms, symlink_perms
    };
    class file_status;
    struct space_info  // returned by space function
    {
      uintmax_t capacity;
      uintmax_t free; 
      uintmax_t available; // free space available to non-privileged process
    };
    enum class copy_option
    {
      none
      fail_if_exists = none,
      overwrite_if_exists
    };
    enum class symlink_option
    {
      none
      no_recurse = none,
      recurse
    };
    // operational functions
    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, system::error_code& ec);
    path         canonical(const path& p, const path& base,
                   system::error_code& ec);
    void         copy(const path& from, const path& to);
    void         copy(const path& from, const path& to,
                   system::error_code& ec);
    void         copy_directory(const path& from, const path& to);
    void         copy_directory(const path& from, const path& to,
                   system::error_code& ec);
    void         copy_file(const path& from, const path& to);
    void         copy_file(const path& from, const path& to,
                   system::error_code& ec);
    void         copy_file(const path& from, const path& to,
                   copy_option option);
    void         copy_file(const path& from, const path& to,
                   copy_option option, system::error_code& ec);
    void         copy_symlink(const path& existing_symlink,
                   const path& new_symlink);
    void         copy_symlink(const path& existing_symlink,
                   const path& new_symlink, system::error_code& ec);
    bool         create_directories(const path& p);
    bool         create_directories(const path& p,
                   system::error_code& ec);
    bool         create_directory(const path& p);
    bool         create_directory(const path& p, system::error_code& ec);
    void         create_directory_symlink(const path& to,
                   const path& new_symlink);
    void         create_directory_symlink(const path& to,
                   const path& new_symlink, system::error_code& ec);
    void         create_hard_link(const path& to, const path& new_hard_link);
    void         create_hard_link(const path& to, const path& new_hard_link,
                                  system::error_code& ec);
    void         create_symlink(const path& to, const path& new_symlink);
    void         create_symlink(const path& to, const path& new_symlink,
                                system::error_code& ec);
    path         current_path();
    path         current_path(system::error_code& ec);
    void         current_path(const path& p);
    void         current_path(const path& p, system::error_code& ec);
    bool         exists(file_status s) noexcept;
    bool         exists(const path& p);
    bool         exists(const path& p, system::error_code& ec) noexcept;
    bool         equivalent(const path& p1, const path& p2);
    bool         equivalent(const path& p1, const path& p2,
                   system::error_code& ec);
    uintmax_t    file_size(const path& p);
    uintmax_t    file_size(const path& p, system::error_code& ec);
    uintmax_t    hard_link_count(const path& p);
    uintmax_t    hard_link_count(const path& p, system::error_code& ec);
    const path&  initial_path();
    const path&  initial_path(system::error_code& ec);
    bool         is_directory(file_status s) noexcept;
    bool         is_directory(const path& p);
    bool         is_directory(const path& p,
                   system::error_code& ec) noexcept;
    bool         is_empty(const path& p);
    bool         is_empty(const path& p, system::error_code& ec);
    bool         is_other(file_status s) noexcept;
    bool         is_other(const path& p,);
    bool         is_other(const path& p, system::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,
                   system::error_code& ec) noexcept;
    bool         is_symlink(file_status s noexcept);
    bool         is_symlink(const path& p);
    bool         is_symlink(const path& p, system::error_code& ec) noexcept;
    std::time_t  last_write_time(const path& p);
    std::time_t  last_write_time(const path& p, system::error_code& ec);
    void         last_write_time(const path& p, const std::time_t new_time);
    void         last_write_time(const path& p, const std::time_t new_time,
                                 system::error_code& ec);
    path         read_symlink(const path& p);
    path         read_symlink(const path& p, system::error_code& ec);
    
    path         relative(const path& p, system::error_code& ec);
    path         relative(const path& p, const path& base=current_path());
    path         relative(const path& p,
                     const path& base, system::error_code& ec);
    bool         remove(const path& p);
    bool         remove(const path& p, system::error_code& ec);
    uintmax_t    remove_all(const path& p);
    uintmax_t    remove_all(const path& p, system::error_code& ec);
    void         rename(const path& from, const path& to);
    void         rename(const path& from, const path& to,
                   system::error_code& ec);
    void         resize_file(const path& p, uintmax_t size);
    void         resize_file(const path& p, uintmax_t size,
                   system::error_code& ec);
    space_info   space(const path& p);
    space_info   space(const path& p, system::error_code& ec);
    file_status  status(const path& p);
    file_status  status(const path& p, system::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,
                   system::error_code& ec) noexcept;
    path         system_complete(const path& p);
    path         system_complete(const path& p, system::error_code& ec);
    path         temp_directory_path();
    path         temp_directory_path(system::error_code& ec);
    path         unique_path(const path& model="%%%%-%%%%-%%%%-%%%%");
    path         unique_path(const path& model, system::error_code& ec);
    path         weakly_canonical(const path& p);
    path         weakly_canonical(const path& p, system::error_code& ec);
  }  // namespace filesystem
}  // namespace boost

namespace boost
{
  namespace filesystem
  {
      class path
      {
      public:
        typedef see below                                    value_type;
        typedef std::basic_string<value_type>                string_type;
        typedef std::codecvt<wchar_t, char, std::mbstate_t>  codecvt_type;
        constexpr value_type                                 preferred_separator;
        // constructors and destructor
        path();
        path(const path& p);
        path(path&& p) noexcept;
        template <class Source>
          path(Source const& source, const codecvt_type& cvt=codecvt());
        template <class InputIterator>
          path(InputIterator begin, InputIterator end,
            const codecvt_type& cvt=codecvt());
       ~path();
        // assignments
        path& operator=(const path& p);
        path& operator=(path&& p) noexcept;
        template <class Source>
          path& operator=(Source const& source);
        template <class Source>
          path& assign(Source const& source, const codecvt_type& cvt)
        template <class InputIterator>
          path& assign(InputIterator begin, InputIterator end,
            const codecvt_type& cvt=codecvt());
        // appends
        path& operator/=(const path& p);
        template <class Source>
          path& operator/=(Source const& source);
        template <class Source>
          path& append(Source const& source, const codecvt_type& cvt);
        template <class InputIterator>
          path& append(InputIterator begin, InputIterator end,
            const codecvt_type& cvt=codecvt());
        // concatenation
        path& operator+=(const path& x);
        path& operator+=(const string_type& x);
        path& operator+=(const value_type* x);
        path& operator+=(value_type x);
        template <class Source>
          path& operator+=(Source const& x);
        template <class CharT>
          path& operator+=(CharT x);
        template <class Source>
          path& concat(Source const& x, const codecvt_type& cvt);
        template <class InputIterator>
          path& concat(InputIterator begin, InputIterator end);
        template <class InputIterator>
          path& concat(InputIterator begin, InputIterator end,
            const codecvt_type& cvt);
        
        // modifiers
        void  clear();
        path& make_preferred();
        path& remove_filename();
        path& replace_extension(const path& new_extension = path());
        void  swap(path& rhs);
        // lexical operations
        path lexically_normal() const;
        path lexically_relative(const path& base) const;
        // native format observers
        const string_type&  native() const noexcept;  // native format, encoding
        const value_type*   c_str() const noexcept;   // native().c_str()
        string_type::size_type size() const noexcept; // native().size()
        template <class String>
          String  string(const codecvt_type& cvt=codecvt()) const;
        string    string(const codecvt_type& cvt=codecvt()) const;
        wstring   wstring(const codecvt_type& cvt=codecvt()) const;
        u16string u16string() const;
        u32string u32string() const;
        // generic format observers
        template <class String>
          String  generic_string() const;
        string    generic_string(const codecvt_type& cvt=codecvt()) const; 
        wstring   generic_wstring(const codecvt_type& cvt=codecvt()) const;
        u16string generic_u16string()
        u32string generic_u32string()
        // compare
        int   compare(const path& p) const noexcept;
        int   compare(const std::string& s) const;
        int   compare(const value_type* s) const;
        // decomposition
        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;
        // query
        bool empty() const;
        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;
        // iterators
        class iterator;
        typedef iterator const_iterator;
        class reverse_iterator;
        typedef reverse_iterator const_reverse_iterator;
        iterator begin() const;
        iterator end() const;
        reverse_iterator rbegin() const;
        reverse_iterator rend() const;
        
        // imbued locale
        static std::locale imbue(const std::locale& loc);
        static const codecvt_type & codecvt();
      private:
        string_type pathname;  // exposition only
      };
  }  // namespace filesystem
}  // namespace boost

template <classSource>
  path(Source const& source, const codecvt_type& cvt=codecvt());

template <classInputIterator>
  path(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());

Эффекты:Содержимое<begin>,<end>или<source>хранится в<pathname>, при необходимости преобразуя формат и кодируяpath.arg.convert].

Итератор для нулевой завершённой байт-струны. Величина должна бытьchar,wchar_t,char16_tили char32_t.

С-массив. Величина должна бытьchar, wchar_t,char16_tилиchar32_t.

Аboost::filesystem::directory_entry.

path constructors [path.construct]

template <class Source>
  path(Source const& source, const codecvt_type& cvt=codecvt());

template <class InputIterator>
  path(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());

Effects: Stores the contents [begin,end) or source in pathname, converting format and encoding if required ([path.arg.convert]).[ORIG_END] -->

path assignments [path.assign]

template <class Source>
  path& operator=(Source const& source);
  template <class Source>
  path& assign(Source const& source, const codecvt_type& cvt);
  template <class InputIterator>
  path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());

Эффекты:Содержимое<begin>,<end>или<source>хранится в<pathname>, при необходимости преобразуя формат и кодируяpath.arg.convert].

Возвращение:<*this>

path appends [path.append]

Операции добавления используют< operator/=>для обозначения их семантического эффекта добавленияпредпочтительного разделителяпри необходимости.

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

Эффекты:

Применяется<path::preferred_separator>к<pathname>, при необходимости преобразуя формат и кодируя [path.arg.convert], если:

• Добавленный разделитель будет избыточным, или

• по отношению к красному календарю, красному календарю,

• < [44] >,

• < [47] >]< [47] >< [47] >*p.native().cbegin().

<p.native()>и<pathname>.

изменит относительный путь к абсолютному пути, или

p.empty()или

*p.native().cbegin()является разделителем каталога.

Then appends p.native() to pathname.[ORIG_END] -->

Возвращение:<*this>

template <class Source>
  path& operator/=(Source const & source);
  template <class Source>
  path& append(Source const & source, const codecvt_type& cvt);
  template <class InputIterator>
  path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());

Эффекты:

Применяется<path::preferred_separator>к<pathname>, при необходимости преобразуя формат и кодируя [path.arg.convert], если:

• Добавленный сепаратор был бы избыточным, или

• , поясняют в пояснительной записке:

• < [44] >,

• < [59] >] [скрыто].

Добавляет содержимое [<begin>,<end>] или<source>к<pathname>, при необходимости преобразовывает формат и кодирует [path.arg.convert].

изменит относительный путь к абсолютному пути, или

p.empty()или

*p.native().cbegin()является разделителем.

Appends the contents [begin,end) or source to pathname, converting format and encoding if required ([path.arg.convert]).[ORIG_END] -->

Возвращение:<*this>

path concatenation [path.concat]

path& operator+=(const path& x);
path& operator+=(const string_type& x);
path& operator+=(const value_type* x);
path& operator+=(value_type x);
template <class Source>
  path& operator+=(Source const& x);
template <class CharT>
  path& operator+=(CharT x);
template <class InputIterator>
  path& concat(InputIterator begin, InputIterator end);
template <class InputIterator>
  path& concat(InputIterator begin, InputIterator end, const codecvt_type& cvt);

Пост-условие:<native() == prior_native +effective-argument>, где<prior_native><native()>до вызова<operator+=>, и<effective-argument>:

• <x.native()>, если<x>присутствует и является<const path&>, в противном случае

• < [67] >,< [67] >< [69] >,< [70] >и< [71] >[скрыто], [< [71] >], [< [67] >], [< [69] >], [< [71] >]

• < [78] >.

Если тип значения<effective-argument>не будет<path::value_type>, фактический аргумент или диапазон аргументов сначала преобразуется так, что<effective-argument>имеет тип значения<path::value_type>.

s, гдеsstd::basic_string<typename std::iterator_traits<InputIterator>::value_type>
s(begin, end), еслиbeginиendаргументы присутствуют, иначе

x.

If the value type of effective-argument would not be path::value_type, the actual argument or argument range is first converted so that effective-argument has value type path::value_type. [ORIG_END] -->

Возвращение:<*this>

path modifiers [path.modifiers]

void clear();

Пост-условие:<this->empty()>верно.

path& make_preferred();

Эффекты:каталог-сепараторs преобразованы впредпочтительный-сепараторs. См.fs.os.examples].

Возвращение:*this

path& remove_filename();

Возвращение:Как будто<*this = parent_path();>

Примечание:Эта функция необходима для эффективной реализации<directory_iterator>. Он открыт для дополнительного использования. Фактическая реализация может быть гораздо более эффективной, чем<*this = parent_path()> — конец примечания.

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

Эффекты:

• Любой существующийextension()удаляется с сохраненного пути, а затем

• iffnew_extensionне пуст и не начинается с точечного символа, точечный символ прилагается к хранимому пути, затем

• new_extensionприлагается к хранимому пути.

Возвращение:*this

void swap(path& rhs) noexcept;

Эффекты:Изменяет содержание двух путей.

Сложность:постоянное время.

path lexical operations [path.lex.ops]

path lexically_normal() const;

Обзор:Возвращает<*this>с избыточным текущим каталогомточка, родительский каталогточка-точкаиэлементы разделителя каталоговудалены.

Возвращение:*this in normal form.

Замечания:Использует<operator/=>для составления обратного пути.

Пример:

<assert(path("foo/./bar/..").lexically_normal() == "foo");
assert(path("foo/.///bar/../").lexically_normal() == "foo/.");>

Вышеприведенные утверждения будут успешными.В Windows символы каталога-сепараторавернули путь's, но это не влияет на равенство<path>.— конечный пример

path lexically_relative(const path& base) const;

Обзор:Возврат<*this>сделан относительно<base>. Рассматривает пустые или идентичные пути как угловые случаи, а не ошибки. Не разрешает симлинки. Не нормализуется сначала<*this>или<base>.

Замечания:Использует<std::mismatch(begin(), end(), base.begin(), base.end())>для определения первого несоответствующего элемента<*this>и<base>. Использует<operator==>для определения соответствия элементов.

Возвращение:

• path()если первый несоответствующий элемент*thisравен begin()или первый несоответствующий элементbaseравенbase.begin()или
   
• path(".")если первый несоответствующий элемент *thisравен end()и первый несоответствующий элементbaseравенbase.end(), или
   
• Объект классаpath, составленный посредством применения operator/= path("..")для каждого элемента в полуоткрытом диапазоне [первый несоответствующий элементbase,base.end()], а затем примененияoperator/=для каждого элемента в полуоткрытом диапазоне [первый несоответствующий элемент*this,end().

Пример:

<assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
assert(path("a/b/c").lexically_relative("a") == "b/c");
assert(path("a/b/c").lexically_relative("a/b/c/x/y") == "../..");
assert(path("a/b/c").lexically_relative("a/b/c") == ".");
assert(path("a/b").lexically_relative("c/d") == "");>

Вышеприведенные утверждения будут успешными.В Windows обратный путь<path>разделителя каталоговбудет обратными, а не прямыми, но это не повлияет на равенство<path>.— конечный пример

Примечание:Если желательны симлинки, следующие семантике, используйте операционную функцию< relative> — конец примечания

Примечание:Еслинормализациянеобходима для обеспечения согласованного соответствия элементов, примените<lexically_normal()>к<*this>,<base>или к обоим.— конец примечания

path native format observers [path.native.obs]

Строка, возвращенная всеми наблюдателями родного формата, находится в форматеродного имени пути.

const string_type&  native() const noexcept;

Возвращение:pathname.

const value_type* c_str() const noexcept;

Возвращение:pathname.c_str().

string_type::size_type size() const noexcept;

Возвращение:<pathname.size()>.

template <class String>
String string(const codecvt_type& cvt=codecvt()) const;

Возвращение:pathname.

Замечания:Если<string_type>отличается от<String>, преобразование выполняется<cvt>.

string string(const codecvt_type& cvt=codecvt()) const;
wstring wstring(const codecvt_type& cvt=codecvt()) const;
u16string u16string() const;
u32wstring u32wstring() const; 

Возвращение:pathname.

Замечания:Если<string_type>является другим типом, чем тип возврата функции, преобразование выполняется<cvt>.

path generic format observers [path.generic.obs]

Строка, возвращенная всеми наблюдателями общего формата, находится вобщем формате имени пути.

template <class String>
String generic_string(const codecvt_type& cvt=codecvt()) const;

Возвращение:pathname.

Замечания:Если<string_type>отличается от<String>, преобразование выполняется<cvt>.

string generic_string(const codecvt_type& cvt=codecvt()) const;
wstring generic_wstring(const codecvt_type& cvt=codecvt()) const;
u16string generic_u16string() const;
u32wstring generic_u32wstring() const; 

Возвращение:pathname.

Замечания:  Если<string_type>является другим типом, чем тип возврата функции, преобразование выполняется<cvt>.

path compare [path.compare]

int compare(const path& p) const noexcept;

Возврат:Значение меньше 0, если элементы<*this>лексикографически меньше элементов<p>, в противном случае значение больше 0, если элементы<*this>лексикографически больше элементов<p>, в противном случае 0.

Замечание: Элементы определяются как бы итерацией в полуоткрытом диапазоне [<begin()>,<end()>] для<*this>и  <p>.

int compare(const std::string& s) const

Возвращение:compare(path(s)).

int compare(const value_type* s) const

Возвращение:compare(path(s)).

path decomposition [path.decompose]

См. таблицуПути разложениядля примеров значений, возвращаемых функциями разложения.Учебниктакже может быть полезным.

path root_name() const;

Возвращение:root-name, if pathname includes root-name, otherwise path().

path root_directory() const;

Возврат:корневая директория, если<pathname>включаеткорневая директория, в противном случае<path()>.

Еслиroot-directoryсостоит изslash name,slashисключается из возвращаемой строки.

path root_path() const;

Возвращение:<root_name() / root_directory()>

path relative_path() const;

Возвращает:A<path>состоит из<pathname>, если<!empty()>, начиная с первогоимени файлапослекорневого пути. В противном случае<path()>.

path parent_path() const;

Возвращается:<(empty() || begin() == —end()) ? path() :pp>, где<pp>сконструирован так, как если бы он начинался с пустого<path>и последовательно применял<operator/=>для каждого элемента в диапазоне<begin()>,<—end()>.

Пример:

std::cout << path("/foo/bar.txt").parent_path(); // outputs "/foo"
std::cout << path("/foo/bar").parent_path();     // outputs "/foo"
std::cout << path("/foo/bar/").parent_path();    // outputs "/foo/bar"
std::cout << path("/").parent_path();            // outputs ""
std::cout << path(".").parent_path();            // outputs ""
std::cout << path("..").parent_path();           // outputs ""

См. последний пункт пули впереднем порядке обхода, почему пример<"/foo/bar/">не выдает<"/foo">.

— конечный пример

path filename() const;

Возвращение:<empty() ? path() : *—end()>

Пример:

std::cout << path("/foo/bar.txt").filename(); // outputs "bar.txt"
std::cout << path("/foo/bar").filename();     // outputs "bar"
std::cout << path("/foo/bar/").filename();    // outputs "."
std::cout << path("/").filename();            // outputs "/"
std::cout << path(".").filename();            // outputs "."
std::cout << path("..").filename();           // outputs ".."

См. последний пункт пули впереднем порядке прохождениясписка, почему пример<"/foo/bar/">не выдает<"bar">.

— конечный пример

path stem(const path& p) const;

Возвращение:если<p.filename()>содержит точку, но не состоит исключительно из одной или двух точек, возвращает подстроку<p.filename()>, начинающуюся в ее начале и заканчивающуюся в последней точке (точка не включена). В обратном случае<p.filename()>.

Пример:

std::cout << path("/foo/bar.txt").stem(); // outputs "bar"
path p = "foo.bar.baz.tar";
for (; !p.extension().empty(); p = p.stem())
  std::cout << p.extension() << '\n';
  // outputs: .tar
  //          .baz
  //          .bar

— конечный пример

path extension(const path& p) const;

Возвращение:если<p.filename()>содержит точку, но не состоит исключительно из одной или двух точек, возвращает подстроку<p.filename()>, начинающуюся с самой правой точки и заканчивающуюся на конце пути. В противном случае возвращается пустой<path>объект.

Замечания:Реализации разрешены, но не требуются для определения дополнительного поведения файловых систем, которые добавляют дополнительные элементы к расширениям, таким как альтернативные потоки данных или имена разделённых наборов данных.

Пример:

std::cout << path("/foo/bar.txt").extension(); // outputs ".txt"

— конечный пример

[Примечание:Точка включена в обратное значение, так что можно различать отсутствие расширения и пустое расширение.См.http://permalink.gmane.org/gmane.comp.lib.boost.devel/199744для более широкого обоснования. — конец примечания

path query [path.query]

bool empty() const;

Возвращение:m_pathname.empty().

bool has_root_path() const;

Возвращение:!root_path().empty()

bool has_root_name() const;

Возвращение:<!root_name().empty()>

bool has_root_directory() const;

Возвращение:!root_directory().empty()

bool has_relative_path() const;

Возвращение:!relative_path().empty()

bool has_parent_path() const;

Возвращение:<!parent_path().empty()>

bool has_filename() const;

Возвращение:!filename().empty()

bool has_stem() const;

Возвращение:!stem().empty()

bool has_extension() const;

Возвращение:!extension().empty()

bool is_absolute() const;

Возврат:<true>если элементы<root_path()>однозначно идентифицируют каталог, то<false>.

bool is_relative() const;

Возвращение:!is_absolute().

path iterators [path.itr]

Итераторы пути<iterator>,<const_iterator>,<reverse_iterator>и<const_reverse_iterator>повторяют элементы сохраненного имени пути.

Итераторы пути - постоянные итераторы, удовлетворяющие требованиям двунаправленного итератора (C++ Std, 24.1.4 Двунаправленные итераторы [lib.bidirectional.iterators]).<value_type>  итератора<path>.

Примечание:Итераторы пути хранят свои объекты ценности внутри и при отмене ссылки на эти внутренние объекты. Они не могут быть использованы с адаптерами итератора, такими как<std::reverse_iterator>, которые предполагают ссылки, полученные путем отнесения точки итератора к объектам, которые переживают сам итератор.— конец примечания

Называть любую неконстантную функцию элемента объекта<path>недействительными все итераторы, относящиеся к элементам этого объекта.

Порядок прохождения вперед выглядит следующим образом:

• корневое имяэлемент, если присутствует.
• Элементкорневой каталог, если он присутствует, в общем формате.[примечание:Для обеспечения правильной работы лексикографического сравнения требуется общий формат.— конец примечания
• Каждый последующий элементимени файла, если он присутствует.
• Дот, если присутствует один или несколько следовых некорневыхслэшсимволов. !

Примечание:Обработка последнего элемента во время итерации в видеточкипри наличии сепаратора отслеживающих каталогов позволяет проводить лексическое (т.е. синтаксическое) различие между путями к каталогам и путями к обычным файлам. Такое различие обычно не имеет значения для операционных систем на основе POSIX и Windows, но может быть требованием для других операционных систем.— конец примечания

Порядок обратного прохождения является обратным по отношению к прямому.

iterator begin() const;

Возвращение:Итератор для первого элемента в прямом порядке прохождения. Если элементов нет, то конечный итератор.

iterator end() const;

Возвращение:Конечный итератор.

reverse_iterator rbegin() const;

Возвращение:Итератор для первого элемента в обратном порядке прохождения. Если элементов нет, то конечный итератор.

reverse_iterator rend() const;

Возвращение:Конечный итератор.

path imbued locale [path.imbued.locale]

<path>операции иногда требуют преобразования кодирования между<pathname>и некоторым другим объектом строки, где один из типов значений<char>, а другой<wchar_t>. Такие преобразования должны выполняться по грани<path::codecvt()>.

Пример:...— конечный пример

static std::locale imbue(const std::locale& loc);

Эффекты:Сохраняется копия<loc>как проникнутая<path>локализация.

Возвращение:Предыдущее проникло<path>локацией.

Замечания:Начальное значение вложенного<path>локала зависит от операционной системы. Он должен быть локальным с гранью<codecvt>для струнного кодирования<char>, подходящего для операционной системы.fs.os.examples].

static const codecvt_type& codecvt();

Возвращение:<codecvt>грань для пропитанной<path>локации.

path deprecated functions

Несколько функций-членов из предыдущих версий<class path>были обесценены либо потому, что они были переименованы, либо потому, что функциональность больше нежелательна или устарела.

Устаревшие функции, доступные по умолчанию; будут подавлены, если<BOOST_FILESYSTEM_NO_DEPRECATED>определено:

path&  remove_leaf()           { return remove_filename(); }
path   leaf() const            { return filename(); }
path   branch_path() const     { return parent_path(); }
bool   has_leaf() const        { return !m_path.empty(); }
bool   has_branch_path() const { return !parent_path().empty(); }

Устаревшие функции, не доступные по умолчанию; будут предоставляться, если<BOOST_FILESYSTEM_DEPRECATED>определено:

const std::string  file_string() const               { return native_string(); }
const std::string  directory_string() const          { return native_string(); }
const std::string  native_file_string() const        { return native_string(); }
const std::string  native_directory_string() const   { return native_string(); }
const string_type  external_file_string() const      { return native(); }
const string_type  external_directory_string() const { return native(); }

path non-member functions [path.non-member]

bool lexicographical_compare(path::iterator first1, path::iterator last1,
                             path::iterator first2, path::iterator last2);

Возвращение:true if the sequence of native() strings for the elements defined by the half-open range [first1,last1) is lexicographically less than the sequence of native() strings for the elements defined by the half-open range [first2,last2). Returns false otherwise.

Замечания:Если две последовательности имеют одинаковое число элементов и их соответствующие элементы эквивалентны, то ни одна последовательность не является лексикографически меньшей, чем другая. Если одна последовательность является префиксом другой, то более короткая последовательность лексикографически меньше, чем более длинная последовательность. В противном случае лексикографическое сравнение последовательностей дает тот же результат, что и сравнение первой соответствующей пары элементов, которые не эквивалентны.

Примечание:Алгоритм<path>, известный<lexicographical_compare>, предоставляется по историческим причинам.— конец примечания

path lexically_normal(const path& p);

Обзор:Возвращение<p>с избыточным текущим каталогомточка, родительский каталогточка-точка, иэлементы разделителя каталоговудалены.

Возвращение:p in normal form.

Замечания:Использует<operator/=>для составления обратного пути.

Пример:

<assert(lexically_normal("foo/./bar/..") == "foo");
assert(lexically_normal("foo/.///bar/../") == "foo/.");>

Все вышеперечисленные утверждения будут успешными.В Windows символы каталога-сепараторавозвращаемого пути'sбудут обратными, а не слэшами, но это не влияет на равенство<path>.— конечный пример

path lexically_relative(const path& p, const path& base);

Обзор:Возврат<p>сделан относительно< base>. Рассматривает пустые или идентичные пути как угловые случаи, а не ошибки. Не разрешает симлинки. Сначала не нормализуется<p>или<base>.

Замечания:Использует<std::mismatch(p.begin(), p.end(), base.begin(), base.end())>для определения первого несоответствующего элемента<p>и<base>. Использует<operator==>для определения соответствия элементов.

Возвращение:

• <path()>, если первый несоответствующий элемент<p>равен<p.begin()>или первый несоответствующий элемент< base>равен<base.begin()>, или
   

• < [128] >,< [129] >,< [130] >и< [131] >< [132] >,
  

• Объект −< [140] >, ввод< [141] >,< [141] >,< [142] >,< [143] >,< [144] >,< [144] >,< [145] >,< [146] >,< [145] >.

Пример:

path(".")если первый несоответствующий элемент pравенp.end()и первый несоответствующий элементbaseравенbase.end(), или
 

Объект классаpath, составленный посредством примененияoperator/= path("..")для каждого элемента в полуоткрытом диапазоне [первый несоответствующий элементbase,base.end()], а затем примененияoperator/=для каждого элемента в полуоткрытом диапазоне [первый несоответствующий элементp,p.end().

[Example:[ORIG_END] -->

<assert(lexically_relative("/a/d", "/a/b/c") == "../../d");
assert(lexically_relative("/a/b/c", "/a/d") == "../b/c");
assert(lexically_relative("a/b/c", "a") == "b/c");
assert(lexically_relative("a/b/c", "a/b/c/x/y") == "../..");
assert(lexically_relative("a/b/c", "a/b/c") == ".");
assert(lexically_relative("a/b", "c/d") == "");>

Все вышеперечисленные утверждения будут успешными.В Windows обратный путь<path>разделителя каталоговбудет обратными, а не прямыми, но это не влияет на равенство<path>.— последний пример

Примечание:Если желательны симлинки, следующие семантике, используйте операционную функцию< relative> — конец примечания

Примечание:Еслинормализациянеобходима для обеспечения последовательного соответствия элементов, оберните<p>,<base>или оба в вызовах< lexically_normal()>.— конец примечания

void swap( path& lhs, path& rhs )

Эффекты:<lhs.swap(rhs)>.

std::size_t hash_value (const path& p);

Возвращение:Значение хэша для пути<p>. Если два пути<p1 == p2>, то<hash_value(p1) == hash_value(p2)>.

Это позволяет использовать пути сBoost.Hash.

bool operator< (const path& lhs, const path& rhs);

Возвращение:return lhs.compare(rhs.begin) < 0.

bool operator<=(const path& lhs, const path& rhs);

Возвращение:<!(rhs < lhs)>.

bool operator> (const path& lhs, const path& rhs);

Возвращение:<rhs < lhs>.

bool operator>=(const path& lhs, const path& rhs);

Возвращение:!(lhs < rhs).

bool operator==(const path& lhs, const path& rhs);

Возвращение:!(lhs < rhs) && !(rhs < lhs).

[править]Примечание:Равенство путейи эквивалентность путей имеют различную семантику.

Равенство определяется<path>нечленом<operator==>, который рассматривает только лексические представления двух путей. Так не бывает<path("foo") == "bar"><true>.

Эквивалентность определяется функцией<equivalent()>, которая определяет, разрешают ли два путиодному и тому же объекту файловой системы. Таким образом,<equivalent("foo", "bar")>будет<true>, когда оба пути разрешатся к одному и тому же файлу.

Программисты, желающие определить, являются ли два пути "одинаковыми", должны решить, означает ли "одинаковое представление" или "разрешить один и тот же фактический файл", и выбрать соответствующую функцию соответственно.— конец примечания

bool operator!=(const path& lhs, const path& rhs);

Возвращение:!(lhs == rhs).

path operator/ (const path& lhs, const path& rhs);

Возвращение:path(lhs) /= rhs.

path inserter and extractor [path.io]

Вставка и вытяжка разграничивают строку двойными котировками<">так, чтобы пути со встроенными пространствами правильно вращались. Амперсанд<&>— это как беглый персонаж, поэтому путь сам по себе может содержать двойные цитаты.

template <class Char, class Traits>
std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
                                             const path& p)

Эффекты:Вставить символы в<os>:

• Двойная цитата.

• Каждый персонаж<p.string<std::basic_string<Char>>()>. Если символ, который должен быть вставлен, равен символу побега или двойной цитате, как определено<operator==>, сначала вставьте символ побега.

• Двойная цитата.

Возвращение:<os>

template <class Char, class Traits>
inline std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is,
                                                    path& p)

Эффекты: < std::basic_string<Char> str;
        is >>boost::io::quoted(str, static_cast<Char>('&'));
        p = str;>

Эффекты:  Извлеките персонажей из os:

• Если первый символ, который будет извлечен, равен двойной цитате, как определеноoperator==, то:
  • Откажитесь от первоначальной двойной цитаты.
  • Сохраните значение, а затем выключите флагskipws.
  • p.clear()
  • До тех пор, пока не будет достигнут неизбежный персонаж с двойной цитатой или is.not_good(), извлеките символы изosи добавьте их кp, за исключением того, что, если персонаж с побегом достигнут, проигнорируйте его и добавьте следующий символ кp.
  • Отбросьте последнего персонажа двойной цитаты.
  • Восстановите флагskipwsдо его первоначального значения.
• В противном случаеos >> p.

Возвращение:<is>

Class filesystem_error [class.filesystem_error]

namespace boost
{
  namespace filesystem
  {
      class filesystem_error : public system_error
      {
      public:
        filesystem_error();
        filesystem_error(const filesystem_error&);
        filesystem_error(const std::string& what_arg,
          system::error_code ec);
        filesystem_error(const std::string& what_arg,
          const path& p1, system::error_code ec);
        filesystem_error(const std::string& what_arg,
          const path& p1, const path& p2, system::error_code ec);
        filesystem_error& filesystem_error(const filesystem_error&);
       ~filesystem_error();
        filesystem_error& operator=(const filesystem_error&);
        const path& path1() const;
        const path& path2() const;
        const char * what() const;
      };
  }  // namespace filesystem
}  // namespace boost

Шаблон класса<filesystem_error>определяет тип брошенных объектов как исключения для сообщения об ошибках файловой системы из функций, описанных в этой справочной документации.

filesystem_error members [filesystem_error.members]

filesystem_error(const std::string& what_arg, error_code ec);

Состояние:

Expression	Value
runtime_error::what()	what_arg.c_str()
code()	ec
path1().empty()	true
path2().empty()	true

filesystem_error(const std::string& what_arg, const path& p1, error_code ec);

Состояние:

Expression	Value
runtime_error::what()	what_arg.c_str()
code()	ec
path1()	Reference to stored copy of p1
path2().empty()	true

filesystem_error(const std::string& what_arg, const path& p1, const path& p2, error_code ec);

Состояние:

Expression	Value
runtime_error::what()	what_arg.c_str()
code()	ec
path1()	Reference to stored copy of p1
path2()	Reference to stored copy of p2

const path& path1() const;

Возвращение:Ссылка на копию<p1>, хранящуюся конструктором, или, если нет, пустой путь.

const path& path2() const;

Возврат:Ссылка на копию<p2>, хранящуюся конструктором, или, если нет, пустой путь.

const char* what() const;

Возвращение:Струна, содержащая<runtime_error::what()>. Точный формат не уточняется. Реализации поощряются, но не требуют включения<path1.native_string()>, если не пустой,<path2.native_string()>, если не пустой, и<system_error::what()>строк в возвращенной строке.

Enum file_type [enum.file_type]

Этот список определяет константы, используемые для идентификации типов файлов.

Постоянное имя	Значение
<status_error>	Ошибка произошла при попытке получить статус файла. Не найденный файлнесчитается ошибкой статуса.
<file_not_found>	Файл не удалось найти
<regular_file>	Обычный файл
<directory_file>	Файл директории
<symlink_file>	Символический файл ссылки
<block_file>	Блокировка специального файла
<character_file>	Специальный файл Character
<fifo_file>	ФИФО или файл трубы
<socket_file>	Сокетный файл
<type_unknown>	Файл существует, но он имеет системный тип, не охваченный ни одним из вышеперечисленных случаев.

Enum perms [enum.perms]

Это<enum>определяет константы битмасс, используемые для идентификации разрешений файлов.ISO/IEC9945 (POSIX) определяет фактические значения, и эти значения были приняты здесь, потому что они очень знакомы и укоренились для многих пользователей POSIX.

Windows: Все разрешения, кроме написания, в настоящее время игнорируются. Существует только одно разрешение на запись; установка разрешения на запись для владельца, группы или других устанавливает разрешение на запись для всех, а удаление разрешения на запись для владельца, группы или других удаляет разрешение на запись для всех.

Имя	Value (octal)	ISO/IEC 9945 macro	Определение или примечания
<no_perms>	<0>		Нет никаких разрешений, установленных для файла. Примечание:<file_not_found>является<no_perms>, а не<perms_not_known>
<owner_read>	<0400>	<S_IRUSR>	Читайте разрешение, владелец
<owner_write>	<0200>	<S_IWUSR>	Написать разрешение, владелец
<owner_exe>	<0100>	<S_IXUSR>	Выполнение / поиск разрешения, владелец
<owner_all>	<0700>	<S_IRWXU>	Чтение, письмо, выполнение/поиск владельцем;<owner_read | owner_write | owner_exe>
<group_read>	<040>	<S_IRGRP>	Читать Разрешение, группа
<group_write>	<020>	<S_IWGRP>	Разрешение на запись, группа
<group_exe>	<010>	<S_IXGRP>	Выполнение/разрешение на поиск, группа
<group_all>	<070>	<S_IRWXG>	Чтение, письмо, выполнение/поиск группой<group_read | group_write | group_exe>
<others_read>	<04>	<S_IROTH>	Читать разрешения, другие
<others_write>	<02>	<S_IWOTH>	Пишите разрешения, другие
<others_exe>	<01>	<S_IXOTH>	Выполнение / поиск разрешения, другие
<others_all>	<07>	<S_IRWXO>	Чтение, письмо, выполнение/поиск другими<others_read | others_write | others_exe>
<all_all>	<0777>		<owner_all | group_all | others_all>
<set_uid_on_exe>	<04000>	<S_ISUID>	Set-user-ID при исполнении
<set_gid_on_exe>	<02000>	<S_ISGID>	Set-group-ID для исполнения
<sticky_bit>	<01000>	<S_ISVTX>	Операционная система зависима. Непереносимые даже между операционными системами ISO/IEC 9945.
<perms_mask>	<07777>		<all_all | set_uid_on_exe | set_gid_on_exe | sticky_bit>
<perms_not_known>	<0xFFFF>		Разрешения не известны, например, когда объект<file_status>создается без указания разрешений.
<add_perms>	<0x1000>		<permissions()>добавляет биты разрешения аргумента к текущим битам файла.
<remove_perms>	<0x2000>		<permissions()>удаляет биты разрешения аргумента из текущих битов файла.
<symlink_perms>	<0x4000>		По ИСО/МЭК9945<permissions()>разрешает симлинки, если не указано<symlink_perms>. Без смысла в Windows< permissions()>никогда не разрешает симлинки. Бессмысленно на Mac OS X и некоторых других BSD-системах, так как< permissions()>всегда разрешает симлинки. Перестань.

Class file_status [class.file_status]

namespace boost
{
  namespace filesystem
  {
      class file_status
      {
      public:
        // constructors
        file_status() noexcept;
        explicit file_status(file_type ft, perms prms = perms_not_known) noexcept;
        // compiler generated
        file_status(const file_status&) noexcept;
        file_status& operator=(const file_status&) noexcept;
       ~file_status() noexcept;
        // observers
        file_type  type() const noexcept;
        perms      permissions() const noexcept;
        // modifiers
        void       type(file_type ft) noexcept;
        void       permissions(perms prms) noexcept;
      };
  }  // namespace filesystem
}  // namespace boost

Объект типа<file_status>хранит информацию о типе и разрешениях файла.

file_status constructors [file_status.cons]

explicit file_status() noexcept;

Постусловия:<type() == status_error>,<permissions() == perms_not_known>.

explicit file_status(file_type ft, perms prms = perms_not_known) noexcept;

Постусловия:<type() == ft>,<permissions() == prms>.

file_status observers [file_status.obs]

file_type type() const noexcept;

Возвращение:Значение<type()>, указанное впостусловияхпоследнего вызова конструктору, оператору = или<type(file_type)>функции.

perms permissions() const noexcept;

Возвращение:Значение<permissions()>, указанное впостусловияхпоследнего вызова конструктору, оператору = или<permissions(perms)>функции.

file_status modifiers [file_status.mods]

void type(file_type ft) noexcept;

Постусловия:<type() == ft>.

void permissions(perms prms) noexcept;

Постусловия:<permissions() == prms>.

Class directory_entry [class.directory_entry]

namespace boost
{
  namespace filesystem
  {
      class directory_entry
      {
      public:
        // constructors and destructor
        directory_entry();
        directory_entry(const directory_entry&);
        explicit directory_entry(const path& p, file_status st=file_status(),
          file_status symlink_st=file_status());
       ~directory_entry(); 
        // modifiers
        directory_entry& operator=(const directory_entry&);
        void assign(const path& p, file_status st=file_status(),
          file_status symlink_st=file_status());
        void replace_filename(const path& p, file_status st=file_status(),
          file_status symlink_st=file_status());
        // observers
        const path&  path() const;
        file_status  status() const;
        file_status  status(system::error_code& ec) const;
        file_status  symlink_status() const;
        file_status  symlink_status(system::error_code& ec) const;
        bool operator< (const directory_entry& rhs);
        bool operator==(const directory_entry& rhs); 
        bool operator!=(const directory_entry& rhs); 
        bool operator< (const directory_entry& rhs);
        bool operator<=(const directory_entry& rhs);
        bool operator> (const directory_entry& rhs);
        bool operator>=(const directory_entry& rhs);
      private:
        path                 m_path;           // for exposition only
        mutable file_status  m_status;         // for exposition only; stat()-like
        mutable file_status  m_symlink_status; // for exposition only; lstat()-like
      };
  }  // namespace filesystem
}  // namespace boost

Объект<directory_entry>хранит<path object>, объект<file_status>для несимволического статуса ссылки и объект<file_status>для символического статуса ссылки. Объекты<file_status>действуют как ценностные тайники.

Примечание:Поскольку<status()>на имени пути может быть относительно дорогой операцией, некоторые операционные системы предоставляют информацию о состоянии в качестве побочного продукта итерации каталогов. Кэширование такой информации о состоянии может привести к значительной экономии времени. Кэшированные и некэшированные результаты могут отличаться в присутствии рас файловой системы.— конец примечания

Фактические сроки итерации с холодной загрузкой по каталогу с 15 047 записями составляли шесть секунд для некэшированных запросов статуса по сравнению с одной секундой для кэшированных запросов статуса. Windows XP, процессор 3.0 ГГц, с умеренно быстрым жестким диском. Аналогичные ускорения ожидаются в системах на базе Linux и BSD, которые обеспечивают статус побочного продукта итерации каталогов.

directory_entry constructors [directory_entry.cons]

directory_entry();

Состояние:

Expression	Value
path().empty()	true
status()	file_status()
symlink_status()	file_status()

explicit directory_entry(const path& p, file_status st=file_status(), file_status symlink_st=file_status());

Состояние:

Expression	Value
path()	p
status()	st
symlink_status()	symlink_st

directory_entry modifiers [directory_entry.mods]

void assign(const path& p, file_status st=file_status(), file_status symlink_st=file_status());

Состояние:

Expression	Value
path()	p
status()	st
symlink_status()	symlink_st

void replace_filename(const path& p, file_status st=file_status(), file_status symlink_st=file_status());

Состояние:

Expression	Value
path()	path().branch() / s
status()	st
symlink_status()	symlink_st

directory_entry observers [directory_entry.obs]

const path& path() const;

Возвращение:<m_path>

file_status status() const;
file_status status(system::error_code& ec) const;

Эффекты:Как будто

if ( !status_known( m_status ) )
{
  if ( status_known(m_symlink_status) && !is_symlink(m_symlink_status) )
    { m_status = m_symlink_status; }
  else { m_status = status(m_path[, ec]); }
}

Возвращение:m_status

Броски:Как указано вСообщение об ошибке (1959).

file_status  symlink_status() const;
file_status  symlink_status(system::error_code& ec) const;

Эффекты:Как будто

if ( !status_known( m_symlink_status ) )
{
  m_symlink_status = symlink_status(m_path[, ec]);
}

Возвращение:m_symlink_status

Броски:Как указано вСообщение об ошибке (1959).

bool operator==(const directory_entry& rhs);

Возвращение:m_path == rhs.m_path.

bool operator!=(const directory_entry& rhs);

Возвращение:m_path != rhs.m_path.

bool operator< (const directory_entry& rhs);

Возвращение:m_path < rhs.m_path.

bool operator<=(const directory_entry& rhs);

Возвращение:m_path <= rhs.m_path.

bool operator> (const directory_entry& rhs);

Возвращение:<m_path > rhs.m_path>.

bool operator>=(const directory_entry& rhs);

Возвращение:m_path >= rhs.m_path.

Class directory_iterator [class.directory_iterator]

Объекты типа<directory_iterator>обеспечивают стандартную итерацию библиотеки по содержимому каталога. См. также класс<recursive_directory_iterator>.

namespace boost
{
  namespace filesystem
  {
      class directory_iterator
      {
      public:
        // member functions
        directory_iterator() noexcept;  // creates the "end" iterator
        directory_iterator(const directory_iterator&);
        explicit directory_iterator(const path& p);
        directory_iterator(const path& p, system::error_code& ec);
       ~directory_iterator();
        directory_iterator& operator=(const directory_iterator&);
        directory_iterator& operator++();
        directory_iterator& increment(system::error_code& ec);
        // other members as required by
        //  C++ Std, 24.1.1 Input iterators [input.iterators]
      };
  }  // namespace filesystem
}  // namespace boost

<directory_iterator>удовлетворяет требованиям итератора ввода (C++ Std, 24.2.1, Итераторы ввода [input.iterators]).

A<directory_iterator>читает последовательные элементы из каталога, для которого он был построен, как будто позвонив по ISO/IEC 9945<readdir_r()>. После того, как построен<directory_iterator>, и каждый раз, когда<operator++>называется, он читает элемент каталога и хранит информацию о нем в объекте типа<directory_entry>.<operator++>не является сохранением равенства; то есть<i == j>не подразумевает, что<++i == ++j>.

Примечание:Практическим следствием несохранения равенства является то, что итераторы каталогов могут использоваться только для алгоритмов с одним проходом.— конец примечания

Если конец элементов каталога достигнут, итератор должен стать равным значению конечного итератора. Конструктор<directory_iterator()>без аргументов всегда конструирует конечный итератор, который должен быть единственным действительным итератором для конечного условия. Результат<operator*>на конечном итераторе не определен. Для любого другого итератора возвращается значение a<const directory_entry&>. Результатом<operator->>на конечном итераторе является неопределенное поведение. Для любого другого итератора возвращается значение a<const directory_entry*>.

Два конечных итератора всегда равны. Конечный итератор не должен быть равен неконцевому итератору.

Вышеприведенная формулировка основана на стандартной формулировке istream_iterator библиотеки.

Результатом вызова<path()>члена<directory_entry>объекта, полученного путем отнесения к<directory_iterator>, является ссылка на<path>объект, состоящий из аргумента каталога, из которого был построен итератор с именем файла записи каталога, добавленной как будто<operator/=>.

Итерация каталогов не должна приводить записи каталогов для текущих (точек) и исходных (точек) каталогов.

Порядок записей в каталогах, полученных путем отмены ссылок на последовательные приращения<directory_iterator>, не определен.

Примечание:Программы, выполняющие итерацию каталогов, могут захотеть проверить, действительно ли существует путь, полученный путем отмены ссылки на итератор каталогов. Это может быть символическая ссылка на несуществующий файл. Программы, рекурсивно идущие по деревьям каталогов с целью удаления и переименования записей, могут избегать использования символических ссылок.

Если файл удаляется из каталога или добавляется в него после построения каталога<directory_iterator>, не уточняется, приведет ли последующее увеличение итератора к итератору, значением которого является удаленная или добавленная запись каталога. См. ISO/IEC 9945<readdir_r()>.— конец примечания

directory_iterator members [directory_iterator.members]

<directory_iterator() noexcept;>

Эффекты:Конструирует конечный итератор.

explicit directory_iterator(const path& p);
directory_iterator(const path& p, system::error_code& ec);

Эффекты:Конструирует итератор, представляющий первую запись в каталоге<p>, решает, если таковой имеется; в противном случае, конечный итератор.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Для итерации по текущему каталогу используйте<directory_iterator(".")>, а не<directory_iterator("")>.— конец примечания

directory_iterator& operator++();
directory_iterator& increment(system::error_code& ec);

Эффекты:Как указано в стандарте C++, 24.1.1 Итераторы ввода [input.iterators]

Возвращение:*this.

Броски:Как указано вСообщение об ошибке (1959).

directory_iterator non-member functions

const directory_iterator& begin(const directory_iterator& iter);

Возвращение:<iter>

directory_iterator end(const directory_iterator&);

Возвращение:<directory_iterator()>.

Class recursive_directory_iterator [class.rec.dir.itr]

Объекты типа<recursive_directory_iterator>обеспечивают стандартную итерацию библиотеки по содержанию каталога, включая рекурсию в его подкаталоги.

namespace boost
{
  namespace filesystem
  {
      class recursive_directory_iterator :
        public iterator<input_iterator_tag, directory_entry>
      {
      public:
        // constructors and destructor
        recursive_directory_iterator() noexcept;
        recursive_directory_iterator(const recursive_directory_iterator&);
        explicit recursive_directory_iterator(const path& p,
          symlink_option opt = symlink_option::none);
        recursive_directory_iterator(const path& p,
          symlink_option opt, system::error_code& ec);
        recursive_directory_iterator(const path& p, system::error_code& ec);
       ~recursive_directory_iterator();
        // observers
        int level() const noexcept;
        bool no_push_pending() const noexcept;
        // modifiers
        recursive_directory_iterator& operator=(const recursive_directory_iterator&);
        recursive_directory_iterator& operator++();
        recursive_directory_iterator& increment(system::error_code& ec);
        void pop();
        void no_push(bool value=true);
        // other members as required by
        //  C++ Std, Input iterators [input.iterators]
      private:
        // actual data members will probably be stored in a shared object,
        // or some similar mechanism, to achieve the required input iterator
        // copy semantics
        int            m_level;    // for exposition only
        bool           m_no_push;  // for exposition only
        symlink_option m_options;  // for exposition only
      };
  }  // namespace filesystem
}  // namespace boost

Поведение<recursive_directory_iterator>такое же, как и<directory_iterator>, если не указано иное.

• Появлениеrecursive_directory_iterator, указывающего на каталог, приводит к тому, что сам каталог повторяется, как указано функциямиoperator++иincrement.
   
• Когдаrecursive_directory_iteratorдостигает конца каталога, который в настоящее время повторяется, или когдаpop()называется,m_levelуменьшается, и итерация родительского каталога продолжается.

recursive_directory_iterator() noexcept;

Эффекты:Конструирует конечный итератор.

explicit recursive_directory_iterator(const path& p, symlink_option opt = symlink_option::none);
recursive_directory_iterator(const path& p, symlink_option opt, system::error_code& ec);
recursive_directory_iterator(const path& p, system::error_code& ec);

Эффекты:  Конструирует итератор, представляющий первую запись в каталоге<p>решает, если таковой имеется; в противном случае, конечный итератор.

Состояние:Если не будет построен конечный итератор<level() == 0 && no_push_pending() == false && m_options == opt>. Для подписи без аргумента<symlink_option><opt>предполагается<symlink_option::none>.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Для итерации по текущему каталогу используйте<recursive_directory_iterator(".")>, а не<recursive_directory_iterator("")>.— конец примечания

Примечание:По умолчанию<recursive_directory_iterator>не следует за симлинками каталогов. Чтобы следовать за симлинками каталога, укажите<opt>как<symlink_option::recurse>— конец примечания

int level() const noexcept;

Требуется:<*this != recursive_directory_iterator()>.

Возвращение:m_level.

bool no_push_pending() const noexcept;

Требуется:<*this != recursive_directory_iterator()>.

Возвращение:m_no_push.

recursive_directory_iterator& operator++();
recursive_directory_iterator& increment(system::error_code& ec);

Эффекты:Как указано в стандарте C++, 24.1.1 Итераторы ввода (input.iterators), за исключением:

• Если<!no_push_pending() && is_directory(this->status()) && (!is_symlink(this->symlink_status()) || (m_options & symlink_option::recurse) != 0)>, то<m_level>увеличивается, и каталог<(*this)->path()>рекурсивно повторяется.
   

• Если на этом уровне больше нет записей каталогов, тоm_levelуменьшается и повторяется родительский каталог.

Постусловие:<no_push_pending() == false>.

Возвращение:*this.

Броски:Как указано вСообщение об ошибке (1959).

void pop();

Требуется:<*this != recursive_directory_iterator()>.

Эффекты:Если<level() == 0>, установите<*this>на<recursive_directory_iterator()>. В противном случае<--m_level>прекратите повторение каталога, который в настоящее время повторяется, и продолжайте повторение над родительским каталогом.

void no_push(bool value=true);

Требуется:<*this != recursive_directory_iterator()>.

Постусловие:<no_push_pending() == value>.

Примечание:<no_push()>используется для предотвращения нежелательной рекурсии в каталог.— конец примечания

recursive_directory_iterator non-member functions

const recursive_directory_iterator& begin(const recursive_directory_iterator& iter);

Возвращение:<iter>

recursive_directory_iterator end(const recursive_directory_iterator&);

Возвращение:<recursive_directory_iterator()>.

Operational functions [fs.op.funcs]

Операционные функции запрашивают или изменяют файлы, включая каталоги, во внешнем хранилище.

Операционные функции получают доступ к файлу, разрешая объект класса<path>к конкретному файлу в иерархии файлов. Путь решается как по механизму ISO/IEC 9945Pathname Resolution.

[править]Примечание:Поскольку аппаратные сбои, сетевые сбои,расы файловых системи многие другие виды ошибок часто происходят в операциях файловой системы, пользователи должны знать, что любая операционная функция файловой системы, независимо от того, насколько она безобидна, может столкнуться с ошибкой.  См.Отчет об ошибках.— конец примечания

path absolute(const path& p, const path& base=current_path());

Возвращение:Абсолютный путьсоставлен по следующей таблице

	p. has_root_directory()	!p.has_root_directory()
p.has_root_name()	return p	return  p.root_name()  / absolute(base)     .root_directory()  / absolute(base)     .relative_path()  / p.relative_path()
!p.has_root_name()	return  absolute(base)   .root_name()  / p	return absolute(base)  / p

Примечание:Для возвратного пути<rp,><rp.is_absolute()>верно.— конец примечания

Бросает:Если<base.is_absolute()>верно, бросает только в том случае, если выделение памяти не удается.

path canonical(const path& p, const path& base = current_path());
path canonical(const path& p, system::error_code& ec);
path canonical(const path& p, const path& base, system::error_code& ec);

Обзор:Преобразует<p>, который должен существовать, в абсолютный путь, который не имеет символической связи,точкаилиточкаэлементы.

Возврат:Канонический путь, который относится к тому же объекту файловой системы, что и<absolute(p,base)>. Для перегрузки без аргумента<base><base><current_path()>.

Броски:  Как указано вСообщение об ошибке.

Замечания:<!exists(p)>— ошибка.

Примечание:Канонические названия путей позволяют проверять безопасность пути (например, живет ли этот путь в /home/goodguy или /home/badguy?)

void copy(const path& from, const path& to);
void copy(const path& from, const path& to, system::error_code& ec);

Эффекты:Как будто

file_status s(symlink_status(from[, ec]));
if(is_symlink(s))
  copy_symlink(from, to[, ec]);
else if(is_directory(s))
  copy_directory(from, to[, ec]);
else if(is_regular_file(s))
  copy_file(from, to, copy_option::fail_if_exists[, ec]);
else
 Report error as specified in Error reporting.

Броски:Как указано вСообщение об ошибке (1959).

void copy_directory(const path& from, const path& to);
void copy_directory(const path& from, const path& to, system::error_code& ec);

Эта функция названа слабо; вероятно, она должна быть перегрузкой<create_directory>с дополнительным аргументом.

Эффекты:Создает каталог<to>, с атрибутами, скопированными из каталога<from>. Набор скопированных атрибутов зависит от операционной системы.

[Note: For ISO 9945/POSIX based operating systems the attributes are those copied by native API stat(from.c_str(), &from_stat) followed by mkdir(to.c_str(),from_stat.st_mode).  For Windows based operating systems the attributes are those copied by native API CreateDirectoryExW(from.c_str(), to.c_str(), 0).  —end note]

Броски:Как указано вСообщение об ошибке (1959).

void copy_file(const path& from, const path& to);
void copy_file(const path& from, const path& to, system::error_code& ec);

Эффекты:copy_file(from, to, copy_option::fail_if_exists[, ec]).

Броски:Как указано вСообщение об ошибке (1959).

void copy_file(const path& from, const path& to, copy_option option);
void copy_file(const path& from, const path& to, copy_option option, system::error_code& ec);

Эффекты:Если<option == copy_option::><fail_if_exists && exists(to)>, сообщается об ошибке. В противном случае содержимое и атрибуты файла<from>решаются для копирования в файл<to>решает для.

Броски:Как указано вСообщение об ошибке (1959).

void copy_symlink(const path& existing_symlink, const path& new_symlink);
void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec);

Эффекты:<create_symlink(read_symlink(existing_symlink><, ec><), new_symlink><, ec><)>.

Броски:Как указано вСообщение об ошибке (1959).

bool create_directories(const path& p);
bool create_directories(const path& p, system::error_code& ec);

Эффекты:Устанавливает послеусловие, вызывая< create_directory()>для любого элемента<p>, который не существует.

Состояние:<is_directory(p)>

Возвращение:true if a new directory was created, otherwise false.

Броски:Как указано вСообщение об ошибке (1959).

Сложность:O(n+1), гдеn— число элементов<p>, которые не существуют.

bool create_directory(const path& p);
bool create_directory(const path& p, system::error_code& ec);

Эффекты:Устанавливает послеусловие, пытаясь создать каталог<p>решает, как по ISO/IEC 9945< mkdir()>со вторым аргументом S_IRWXU | S_IRWXG | S_IRWXO. Сбой в создании, поскольку<p>решает существующий каталог, не должен рассматриваться как ошибка.

Состояние:<is_directory(p)>

Возвращается:<true>, если был создан новый каталог, в противном случае<false>.

Броски:Как указано вСообщение об ошибке (1959).

void create_directory_symlink(const path& to, const path& new_symlink);
void create_directory_symlink(const path& to, const path& new_symlink, system::error_code& ec);

Эффекты:Устанавливает послеусловие, как по ISO/IEC 9945<symlink()>.

Посткондиция:<new_symlink>разрешает символический файл ссылки, который содержит неопределенное представление<to>.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Некоторые операционные системы, такие как Windows, требуют создания симлинков, чтобы определить, что ссылка находится в каталоге. Портативный код должен использовать<create_directory_symlink()>для создания ссылок каталогов, а не<create_symlink()>— конец примечания

Примечание:Некоторые операционные системы вообще не поддерживают символические ссылки или поддерживают их только для обычных файлов. Некоторые файловые системы не поддерживают символические ссылки независимо от операционной системы - например, файловая система FAT, используемая на картах памяти и флэш-накопителях.— конец примечания

void create_hard_link(const path& to, const path& new_hard_link);
void create_hard_link(const path& to, const path& new_hard_link, system::error_code& ec);

Эффекты:Устанавливает послеусловие, как по ISO/IEC 9945<link()>.

Состояние:

•  exists(to) && exists(new_hard_link) && equivalent(to, new_hard_link)
• Содержимое файла или каталогаtoостается неизменным.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Некоторые операционные системы вообще не поддерживают жесткие ссылки или поддерживают их только для обычных файлов. Некоторые файловые системы не поддерживают жесткие ссылки независимо от операционной системы - например, файловая система FAT, используемая на картах памяти и флэш-накопителях. Некоторые файловые системы ограничивают количество ссылок на файл.— конец примечания

void create_symlink(const path& to, const path& new_symlink);
void create_symlink(const path& to, const path& new_symlink, system::error_code& ec);

Эффекты:Устанавливает послеусловие, как по ISO/IEC 9945<symlink()>.

Посткондиция:<new_symlink>разрешает символический файл ссылки, который содержит неопределенное представление<to>.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Некоторые операционные системы вообще не поддерживают символические ссылки или поддерживают их только для обычных файлов. Некоторые файловые системы не поддерживают символические ссылки независимо от операционной системы - например, система FAT, используемая на картах памяти и флэш-накопителях.— конец примечания

path current_path();
path current_path(system::error_code& ec);

Возвращение:Текущий рабочий путь каталога, как если бы ISO/IEC 9945<getcwd()>.<is_absolute()>соответствует обратному пути.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Название<current_path()>было выбрано, чтобы подчеркнуть, что возвращение — это путь, а не просто одно имя каталога.

Текущий путь, возвращаемый многими операционными системами, является опасной глобальной переменной. Он может быть неожиданно изменен сторонними или системными библиотечными функциями или другим потоком.— конец примечания

void current_path(const path& p);
void current_path(const path& p, system::error_code& ec);

Эффекты:Устанавливает послеусловие, как будто по ISO/IEC 9945<chdir()>.

Пост-условие:<equivalent(p, current_path())>.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Нынешний путь для многих операционных систем — опасное глобальное состояние. Он может быть неожиданно изменен сторонними или системными библиотечными функциями или другим потоком. — конец примечания

bool exists(file_status s) noexcept;

Возвращение:status_known(s) && s.type() != file_not_found

bool exists(const path& p);
bool exists(const path& p, system::error_code& ec) noexcept;

Возвращение:exists(status(p)) or exists(status(p, ec)), respectively. If ec != 0 and an error

Броски:Как указано вСообщение об ошибке (1959).

bool equivalent(const path& p1, const path& p2);
bool equivalent(const path& p1, const path& p2, system::error_code& ec);

Эффекты:Определяет<file_status s1>и<s2>, как если бы<status(p1)>и<status(p2)>соответственно.

Возвращение:true, if sf1 == sf2 and p1 and p2 resolve to the same file system entity, else false.

Считается, что два пути разрешаются для одного и того же объекта файловой системы, если два объекта-кандидата находятся на одном и том же устройстве в одном и том же месте. Это определяется как значения структуры ISO/IEC 9945<stat><,>, полученные как будто<stat()>для двух путей, имеющих равные значения<st_dev>и равные значения<st_ino>.

Примечание:ISO/IEC 9945 требует, чтобы"st_devбыл уникальным в локальной сети. Консервативные реализации ISO/IEC 9945 могут также захотеть проверить на равные<st_size>и<st_mtime>значения.Реализации Windowsмогут использовать<GetFileInformationByHandle()>в качестве суррогата для<stat()>и считать "то же" равными значениями для<dwVolumeSerialNumber>,<nFileIndexHigh>,<nFileIndexLow>,<nFileSizeHigh>,<nFileSizeLow>,<ftLastWriteTime.dwLowDateTime>и<ftLastWriteTime.dwHighDateTime>.— конец примечания

Броски:<filesystem_error>, если<(!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))>, иначе как указано вСообщение об ошибке.

uintmax_t file_size(const path& p);
uintmax_t file_size(const path& p, system::error_code& ec);

Возврат:Если<exists(p) && is_regular_file(p)>, размер в байтах файла<p>решает, как если бы значение ISO/IEC 9945<stat>члена структуры<st_size>получено как если бы ISO/IEC 9945<stat()>. В противном случае<static_cast<uintmax_t>(-1)>.

Броски:Как указано вСообщение об ошибке (1959).

uintmax_t hard_link_count(const path& p);
uintmax_t hard_link_count(const path& p, system::error_code& ec);

Возвращение:Количество жестких ссылок<p>.

Броски:Как указано вСообщение об ошибке (1959).

const path& initial_path();
const path& initial_path(system::error_code& ec);

Возвращение:current_path() as of the first call to initial_path().

Примечание:<initial_path()>не является безопасным потоком и может вернуть нежелательный результат, если он вызван после изменения в текущем каталоге. Этих проблем можно избежать, позвонив<initial_path()>немедленно при входе в main(). — конец примечания

Броски:Для первого звонка, как указано вСообщение об ошибке. Последующие звонки ничего не бросают.

bool is_directory(file_status s) noexcept;

Возвращение:<s.type() == directory_file>

bool is_directory(const path& p);
bool is_directory(const path& p, system::error_code& ec) noexcept;

Возвращение:is_directory(status(p)) or is_directory(status(p, ec)), respectively.

Броски:<filesystem_error>; перегрузка<error_code&>ничего не бросает.

bool is_empty(const path& p);
bool is_empty(const path& p, system::error_code& ec);

Эффекты:Определяет<file_status s>, как бы по<status(p, ec)>.

Возвращение:<is_directory(s)
         ? directory_iterator(p) == directory_iterator()
         : file_size(p) == 0;>

bool is_regular_file(file_status s) noexcept;

Возвращение:<s.type() == regular_file>

bool is_regular_file(const path& p);

Возвращение:is_regular_file(status(p)).

Броски:<filesystem_error>, если<status(p)>бросит<filesystem_error.>

bool is_regular_file(const path& p, system::error_code& ec) noexcept;

Эффекты:Наборы<ec>, как если бы<status(p, ec)>.Примечание:<status_error>,<file_not_found>и<type_unknown>случаи устанавливаются<ec>на значения ошибок. Чтобы отличить случаи, вызовите функцию<status>напрямую.— конец примечания

Возвращение:<is_regular_file(status(p, ec))>.

bool is_other(file_status s) noexcept;

Возвращение:return exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)

bool is_other(const path& p);
bool is_other(const path& p, system::error_code& ec) noexcept;

Возвращение:<is_other(status(p))>или<is_other(status(p, ec))>соответственно.

Броски:<filesystem_error>; перегрузка<error_code&>ничего не бросает.

bool is_symlink(file_status s) noexcept;

Возвращение:s.type() == symlink_file

bool is_symlink(const path& p);
bool is_symlink(const path& p, system::error_code& ec) noexcept;

Возвращение:<is_symlink(symlink_status(p))>или<is_symlink(symlink_status(p, ec))>соответственно.

Броски:<filesystem_error>; перегрузка<error_code&>ничего не бросает.

std::time_t last_write_time(const path& p);
std::time_t last_write_time(const path& p, system::error_code& ec);

Возвращение:Время последней модификации данных<p>, определяемое как по значению члена структуры ISO/IEC 9945<stat><st_mtime>  полученное как по ISO/IEC 9945<stat()>.

Броски:Как указано вСообщение об ошибке (1959).

void last_write_time(const path& p, const std::time_t new_time);
void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec);

Эффекты:Устанавливает время последней модификации данных файла, разрешенной<p>к<new_time>, как если бы ISO/IEC 9945<stat()>, за которой следует ISO/IEC 9945<utime()>.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Посткондиция<last_write_time(p) == new_time>не указана, поскольку она может не содержать файловых систем с грубой детализацией времени.— конец примечания

void permissions(const path& p, perms prms);
void permissions(const path& p, perms prms, system::error_code& ec);

Требуется:<!((prms & add_perms) && (prms & remove_perms))>.

Эффекты:Применяет эффективные биты разрешений от<prms>до файла<p>, как если бы ISO/IEC 9945<fchmodat()>. Биты эффективного разрешения определяются, как указано в следующей таблице.

биты, присутствующие в<prms>	Эффективные биты
Ни 1990, ни 1991	<prms & perms_mask>
<add_perms>	<status(p).permissions() | (prms &perms_mask)>
<remove_perms>	<status(p)><.permissions() & ~(prms &perms_mask)>

[Примечание:Концептуально разрешения рассматриваются как биты, но фактическая реализация может использовать какой-то другой механизм.конец примечания

Броски:Как указано вСообщение об ошибке (1959).

path read_symlink(const path& p);
path read_symlink(const path& p, system::error_code& ec);

Возвращение:  Если<p>решается на символическую ссылку, объект<path>, содержащий содержимое этой символической ссылки. В противном случае это пустой объект 2008 года.

Броски:Как указано вОтчет об ошибках.Примечание:Это ошибка, если<p>не решается на символическую ссылку.— конец примечания

path relative(const path& p, system::error_code& ec);

Возвращение:<relative(p, current_path(), ec)>.

Броски:  Как указано в отчете об ошибке.

path relative(const path& p, const path& base=current_path());
path relative(const path& p, const path& base, system::error_code& ec);

Обзор:Возвращение<p>сделано относительно<base>. Рассматривает пустые или идентичные пути как угловые случаи, а не ошибки. Решает симлинки и нормализует как<p>, так и<base>перед другой обработкой.

Возвращение:weakly_canonical(p).lexically_relative(weakly_canonical(base)). The second form returns path() if an error occurs.

Броски:Как указано в отчете об ошибке.

bool remove(const path& p);
bool remove(const path& p, system::error_code& ec);

Эффекты:  Если<exists(symlink_status(p,ec))>, он удаляется как по ISO/IEC 9945<remove()>.

Примечание:Сама символическая ссылка удаляется, а не файл, который она решает удалить.— конец примечания

Посткондиционер:<!exists(symlink_status(p))>.

Возвращение: <false>, если р не существовало в первую очередь, в противном случае<true>.

Броски:Как указано вСообщение об ошибке (1959).

uintmax_t remove_all(const path& p);
uintmax_t remove_all(const path& p, system::error_code& ec);

Эффекты:  Рекурсивно удаляет содержимое p, если оно существует, а затем удаляет сам файл<p>, как будто по ISO/IEC 9945<remove()>.

Примечание:Сама символическая ссылка удаляется, а не файл, который она решает удалить.— конец примечания

Посткондиционер:<!exists(p)>

Возвращение:Количество удаленных файлов.

Броски:Как указано вСообщение об ошибке (1959).

void rename(const path& old_p, const path& new_p);
void rename(const path& old_p, const path& new_p, system::error_code& ec);

Эффекты:Переименование<old_p>в<new_p>, как если бы ISO/IEC 9945<rename()>.

Примечание:Если<old_p>и<new_p>разрешают один и тот же существующий файл, никаких действий не предпринимается. В противном случае, если<new_p>решается на существующий файл, не являющийся каталогом, он удаляется, в то время как<new_p>решается на существующий каталог, он удаляется, если пуст в ISO/IEC 9945, но является ошибкой в Windows. Символическая ссылка сама по себе переименована, а не файл, который она решает переименовать.— конец примечания

Броски:Как указано вСообщение об ошибке (1959).

void resize_file(const path& p, uintmax_t new_size);
void resize_file(const path& p, uintmax_t new_size, system::error_code& ec);

Постусловие:<file_size() == new_size>.

Броски:Как указано вСообщение об ошибке (1959).

Замечания:Достигает своих пост-условий как по ISO/IEC 9945<truncate()>.

space_info space(const path& p);
space_info space(const path& p, system::error_code& ec);

Возвращение:Объект типа<space_info>. Значение объекта<space_info>определяется так, как если бы он использовал ISO/IEC 9945<statvfs()>для получения структуры ISO/IEC 9945<statvfs>, а затем умножил ее<f_blocks>,<f_bfree>и<f_bavail>членов на ее<f_frsize>члена и присвоил результаты<capacity>,<free>и<available>членов соответственно. Любые члены, для которых значение не может быть определено, должны быть установлены на -1.

Броски:Как указано вСообщение об ошибке (1959).

file_status status(const path& p);

Эффекты:Как будто:

system::error_code ec;
file_status result = status(p, ec);
if (result == status_error)
  throw filesystem_error(implementation-supplied-message, p, ec);
return result;

Возвращение:См. выше.

Броски:<filesystem_error>Примечание:<result>значения<file_status(file_not_found)>и<file_status(type_unknown)>не считаются отказами и не вызывают исключения.— конец примечания

file_status status(const path& p, system::error_code& ec) noexcept;

Эффекты:

Если возможно, определяет атрибуты файла<p>решает, как если бы ISO/IEC 9945<stat()>.

If, during attribute determination, the underlying file system API reports an error, sets ec to indicate the specific error reported. Otherwise, ec.clear().

[Примечание:Это позволяет пользователям проверять специфику основных ошибок API, даже если значение, возвращенное<status()>, не<file_status(status_error)>. — конец примечания

Возвращение:

Если<ec != error_code()>:

• Если конкретная ошибка указывает на то, чтоpне может быть решена, поскольку некоторый элемент пути не существует, верните file_status(file_not_found).Примечание:Ошибки ISO/IEC 9945, указывающие на это, являются ENOENT или ENOTDIR. Эквиваленты Windows включают ERROR_FILE_NOT_FOUND, ERROR_PATH_NOT_FOUND, ERROR_INVALID_NAME, ERROR_INVALID_PARAMETER, ERROR_BAD_PATHNAME и ERROR_BAD_NETPATH.— конец примечания
   
• В противном случае, если конкретная ошибка указывает, чтоpможет быть решена, но атрибуты не могут быть определены, верните file_status(type_unknown).Примечание:Например, ошибки Windows ERROR_SHARING_VIOLATION. Для ИСО/МЭК 9945 дело никогда не возникает.— конец примечания]
   
• Возвращение file_status(status_error).

Примечание:Эти семантики различают, что<p>не существует, что<p>существует, но не может определить его атрибуты, и что существует ошибка, которая мешает даже знать, существует ли<p>. Эти различия важны для некоторых случаев использования. — конец примечания

В противном случае

• Если атрибуты указывают на обычный файл, как если бы по ISO/IEC 9945 S_ISREG(), возврат file_status(regular_file).Примечание: regular_fileподразумевает, что соответствующие<fstream>операции будут успешными, при условии отсутствия ошибок аппаратного обеспечения, разрешения, доступа или расы файловой системы. Отсутствиеregular_fileне обязательно означает, что<fstream>операции потерпят неудачу в каталоге.— конец примечания]
   
• В противном случае, если атрибуты указывают каталог, как если бы ISO/IEC 9945S_ISDIR(), возврат file_status(directory_file).Примечание:directory_fileподразумевает, что directory_iterator(p)будет успешным.— конец примечания]
   
• В противном случае, если атрибуты указывают на блок специального файла, как если бы по ISO/IEC 9945S_ISBLK(), возвращают file_status(block_file).
   
• В противном случае, если атрибуты указывают специальный файл символа, как если бы по ISO/IEC 9945S_ISCHR(), верните file_status(character_file).
   
• В противном случае, если атрибуты указывают файл фифо или трубки, как если бы по ISO/IEC 9945S_ISFIFO(), возвращайте file_status(fifo_file)
   
• В противном случае, если атрибуты указывают на розетку, как если бы по ISO/IEC 9945S_ISSOCK(), возвращают file_status(socket_file).
   
• Возвращение file_status(type_unknown).

Замечания:Если символическая ссылка встречается во время разрешения имени пути, разрешение имени пути продолжается с использованием содержимого символической ссылки.

bool status_known(file_status s) noexcept;

Возвращение:s.type() != status_error

file_status symlink_status(const path& p);
file_status symlink_status(const path& p, system::error_code& ec) noexcept;

Эффекты:  То же самое, чтостатус()выше, за исключением того, что атрибуты<p>определяются как если бы ISO/IEC 9945<lstat()>.

Возврат:То же, чтостатус(), выше, за исключением того, что если атрибуты указывают на символическую ссылку, как если бы ISO/IEC 9945S_ISLNK(), возврат<file_status(symlink_file)>.

Замечания:Разрешение Pathname прекращается, если<p>называет символическую ссылку.

Броски:<filesystem_error>; перегрузка<error_code&>ничего не бросает.

path system_complete(const path& p);
path system_complete(const path& p, system::error_code& ec);

Эффекты:Составляет абсолютный путь от<p>, используя те же правила, которые используются операционной системой для разрешения пути, пройденного в качестве аргумента имени файла, к стандартным открытым функциям библиотеки.

Возвращение:Составной путь.

Пост-условие:Для возвратного пути истинно<rp,><rp.is_absolute()>.

Броски:Как указано вСообщение об ошибке (1959).

Примечание:Для ISO/IEC 9945<system_complete(p)>имеет ту же семантику, что и<complete(p, current_path())>.

ДляWindows<system_complete(p)>имеет ту же семантику, что и<complete(ph, current_path())>, если<p.is_absolute() || !p.has_root_name()>или<p>и<base>имеют такую же<root_name()>. В противном случае он действует как<complete(p, kinky)>, где<kinky>является текущим каталогом для диска<p.root_name()>. Это будет текущий каталог этого диска в последний раз, когда он был установлен, и, таким образом, может бытьостаток, оставшийся от предыдущей программыпод управлением командного процессора! Хотя эти семантики часто полезны, они также очень подвержены ошибкам.

См.полное ()примечаниедля предложений по использованию.— конец примечания

path temp_directory_path();
path temp_directory_path(system::error_code& ec);

Возвращение:Путь каталога, подходящий для временных файлов в соответствии с конвенциями операционной системы. Специфика того, как определяется этот путь, определяется реализацией. Ошибка должна быть сообщена, если<!exists(p) || !is_directory(p)>, где<p>путь, который должен быть возвращен.

ISO/IEC 9945: Путь, подаваемый первой переменной среды, находится в списке TMPDIR, TMP, TEMP, TEMPDIR. Если ни один из них не найден,<"/tmp">или, если макро<__ANDROID__>определено,<"/data/local/tmp">.

Windows:Путь, сообщаемыйWindows<GetTempPath>Функция API.

Броски:Как указано вСообщение об ошибке (1959).

[Примечание:Название<temp_directory_path()>было выбрано, чтобы подчеркнуть, что возвращение - это путь, а не просто одно имя каталога.- конец примечания

path unique_path(const path& model="%%%%-%%%%-%%%%-%%%%");
path unique_path(const path& model, system::error_code& ec);

Функция<unique_path>генерирует имя пути, подходящее для создания временных файлов, включая каталоги. Название основано на модели, которая использует символ знака процента, чтобы указать замену случайной шестнадцатеричной цифрой.Примечание:Чем больше битов случайности в имени генерируемого пути, тем меньше вероятность предшествующего существования или угадывания. Каждая замена шестидесятичной цифры в модели добавляет четыре бита случайности. Таким образом, модель по умолчанию обеспечивает 64 бита случайности. Этого достаточно для большинства применений.— конец примечания

Возвращение:Путь, идентичный<model>, за исключением того, что каждое появление символа знака процента заменяется случайным шестидесятичной цифрой в диапазоне 0-9, a-f.

Броски:Как указано вСообщение об ошибке (1959).

Замечания:Реализации поощряются для получения требуемой случайности с помощью криптографически безопасного генератора псевдослучайных чисел, такого как генератор, предоставляемый операционной системой. [Примечание: Такие генераторы могут блокироваться до тех пор, пока не разовьется достаточная энтропия.— конец примечания

path weakly_canonical(const path& p);
path weakly_canonical(const path& p, system::error_code& ec);

Обзор:Возвращается<p>с разрешенными симлинками и результатом нормализуется.

Возвращение:Путь, состоящий из результата вызова функции< canonical>на путь, состоящий из ведущих элементов< p>, которые существуют, если таковые имеются, за которыми следуют элементы<p>, которые не существуют, если таковые имеются.

Состояние:Обратный путь находится внормальной форме.

Замечания:Использует<operator/=>для составления обратного пути. Для определения существования используется функция<status>.

Замечания:Осуществления поощряются, чтобы избежать ненужной нормализации, например, когда<canonical>уже был вызван полностью<p>.

Броски:  Как указано в отчете об ошибке.

 

---

File streams - <boost/filesystem/fstream.hpp>

Замены предоставляются для классов потоков файлов из заголовка стандартной библиотеки C++<<fstream>>. Эти классы замены публично наследуют от стандартных классов библиотеки. В подъёме. Версия файловой системы, конструкторы и открытые функции принимают аргументы<const path&>вместо аргументов< const char*>. Других различий в синтаксисе или семантике нет.

namespace boost
{
  namespace filesystem
  {
    template < class charT, class traits = std::char_traits<charT> >
    class basic_filebuf : public std::basic_filebuf<charT,traits>
    {
    public:
      basic_filebuf<charT,traits>*
        open(const path& p, std::ios_base::openmode mode);
    };
    template < class charT, class traits = std::char_traits<charT> >
    class basic_ifstream : public std::basic_ifstream<charT,traits>
    {
    public:
      explicit basic_ifstream(const path& p, std::ios_base::openmode mode=std::ios_base::in)
      void open(const path& p, std::ios_base::openmode mode=std::ios_base::in);
    };
    template < class charT, class traits = std::char_traits<charT> >
    class basic_ofstream : public std::basic_ofstream<charT,traits>
    {
    public:
      explicit basic_ofstream(const path& p, std::ios_base::openmode mode=std::ios_base::out);
      void open(const path& p, std::ios_base::openmode mode=std::ios_base::out);
    };
    template < class charT, class traits = std::char_traits<charT> >
    class basic_fstream : public std::basic_fstream<charT,traits>
    {
    public:
      explicit basic_fstream(const path& p,
        std::ios_base::openmode mode=std::ios_base::in | std::ios_base::out);
      void open(const path& p,
        std::ios_base::openmode mode=std::ios_base::in | std::ios_base::out);
    };
    typedef basic_filebuf<char> filebuf;
    typedef basic_ifstream<char> ifstream;
    typedef basic_ofstream<char> ofstream;
    typedef basic_fstream<char> fstream;
    typedef basic_filebuf<wchar_t> wfilebuf;
    typedef basic_ifstream<wchar_t> wifstream;
    typedef basic_fstream<wchar_t> wfstream;
    typedef basic_ofstream<wchar_t> wofstream;
    
  }  // namespace filesystem
}  // namespace boost

Path decomposition table

Таблица генерируется программой, составленной с реализацией Boost.

Затененные записи указывают на случаи, когда реализации ISO/IEC 9945 (POSIX) и Windows дают разные результаты. Верхнее значение - результат ISO/IEC 9945 и нижнее значение - результат Windows.

<c:foo>

<c:foo>[<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>] [<path>]<c:foo><c:foo><c:foo><c:foo>

<c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo\><c:foo><c:foo><c:foo\><c:foo><c:foo><c:foo><c:foo><c:foo><c:\foo\><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo><c:foo>Предупреждение: Длинные траектории Windows и префикс расширенной длины\\?\

Microsoft Windows "Максимальное ограничение длины пути" указывает:

В Windows API (за некоторыми исключениями...) максимальная длина пути — MAX_PATH, которая определяется как 260 символов.

API Windows имеет множество функций, которые также имеют версии Unicode, позволяющие прокладывать путь с увеличенной длиной до 32 767 символов. ... Чтобы указать путь с увеличенной длиной, используйте приставку"\\?\". Например, "\\?\D:\очень длинный путь". [C++ строковые буквальные обозначения требуют, конечно, удвоения обратных сокращений.]

Потому что больше всего. Операционные функции файловой системы просто передают содержимое объекта пути класса в API Windows, они работают с префиксами расширенной длины. Но некоторые из них не сработают, потому что ограничения накладываются Windows. Внимательно прочитайте следующие предостережения!

Cautions for paths with extended-length prefixes

• Отдельные компоненты пути по-прежнему ограничены тем, что поддерживается для конкретной файловой системы, обычно 255 символов.
• Только обратные срезы приемлемы в качестве разделителей каталогов. Срезы не рассматриваются как разделители.
• Все пути должны быть абсолютными — относительные пути не допускаются.
• Как только абсолютный путь выходит за пределы 260 символов, он по существу отравляется, и все операции должны использовать префиксы расширенной длины. Так что даже такая простая операция, какcreate_directory("a"), потерпит неудачу, если абсолютный путь полученного каталога превысит 260 символов.
• Определенный рост. Функции файловой системы, которые разлагают свой путь аргументации, а затем работают над отдельными относительными каталогами или файлами, не будут работать должным образом с префиксными путями расширенной длины.

Acknowledgements

Эта библиотека файловых систем посвящена моей жене Сонде, которая оказала поддержку, необходимую для завершения как пробной реализации, так и самого предложения. Она дала мне силы продолжать после трудного года лечения рака в середине всего этого.

Многие люди внесли технические комментарии, идеи и предложения в библиотеку файловой системы Boost. См.http://www.boost.org/libs/filesystem/doc/index.htm#Признания.

Дитмар Кюль внес свой вклад в оригинальный проект Boost Filesystem Library Directory_iterator. Питер Димов, Уолтер Лэндри, Роб Стюарт и Томас Витт были особенно полезны в совершенствовании библиотеки.

Функции create_directories, extension, basename и replace_extension были разработаны Владимиром Прусом. Функцию temp_directory_path разработал Джефф Флинн. Давид Свобода предложил каноническую функцию и предоставил псевдокод.

Говард Хиннант и Джон Мэддок рассмотрели проект предложения версии 2 и выявили ряд ошибок или недостатков, в результате чего получился более полированный итоговый документ.

Питер Димов предложил один классный путь с шаблонами для адаптации к нескольким типам строк. Его идея легла в основу дизайна дорожек версии 3.

References

[ISO/IEC 9945]	ISO/IEC 9945:2003, IEEE Std 1003.1-2001, and The Open Group Base Specifications, Issue 6. Also known as The Single Unix® Specification, Version 3. Available from each of the organizations involved in its creation. For example, read online or download from www.unix.org/single_unix_specification/. The ISO JTC1/SC22/WG15 - POSIX homepage is www.open-std.org/jtc1/sc22/WG15/
[Abrahams]	Dave Abrahams, Error and Exception Handling, www.boost.org/more/error_handling.html

---

© Авторское право Beman Dawes, 2002, 2006, 2007, 2009, 2010, 2011

Распространяется в соответствии с Лицензией на программное обеспечение Boost, версия 1.0. См.www.boost.org/LICENSE_1_0.txt

Пересмотрено25 Октября 201525 October 2015[ORIG_END] -->

Статья Filesystem Reference раздела может быть полезна для разработчиков на c++ и boost.

Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.

---

:: Главная :: ::

---

реклама

---