How similar are Boost.Filesystem and the C++ standard filesystem library?

by

There are a number of differences. Some were, I believe, Boost changes that were never propagated. For example, there is no path.filename_is_dot() query (as discussed below, it would be less useful in std::filesystem anyway).

There was also a good bit of late-breaking news on this front:

  1. Support for non-POSIX-like filesystems:
    • Specify whether a string is OS-native or POSIX-like (or let the implementation decide, which is (still) the default)
    • An implementation may define additional file types (beyond regular, directory, socket, etc.)
    • An implementation may define file_size for a directory or device file
  2. filename(), normalization, and relative/absolute conversions redefined (examples for POSIX):
    • path("foo/.").lexically_normal()=="foo/" (is the opposite in Boost)
    • path("foo/").filename()=="" (is path(".") in Boost)
    • remove_filename() leaves the trailing slash and is thus idempotent (it assigns parent_path() in Boost)
    • path(".profile").extension()=="" (is the whole name in Boost)
    • path decompositions and combinations can preserve things like alternate data stream names that are normally invisible
    • path("foo")/"/bar"=="/bar" (is path("foo/bar") in Boost), which allows composing relative file names with others (absolute or relative) and replaces Boost’s absolute()
    • Boost’s system_complete() (which takes only one argument) is renamed to absolute()
    • canonical() thus takes only one argument (fixed in a DR)
    • lexically_relative() handles .. and root elements correctly
    • permissions() takes more arguments (Boost combines them into a bitmask)

Note that Boost.Filesystem v4 is under development and is supposed to be C++17-compatible (but therefore incompatible in many respects with v3).

More Related Contents:

  1. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  2. What are Aggregates and PODs and how/why are they special?
  3. reinterpret_cast creating a trivially default-constructible object
  4. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  5. Why was std::pow(double, int) removed from C++11?
  6. shared_ptr to an array : should it be used?
  7. When does a constexpr function get evaluated at compile time?
  8. How much is too much with C++11 auto keyword?
  9. Why do I get the same sequence for every run with std::random_device with mingw gcc4.8.1?
  10. Why do C++11-deleted functions participate in overload resolution?
  11. Difference between “if constexpr()” Vs “if()”
  12. Nice way to append a vector to itself
  13. How to return a std::string.c_str()
  14. What does std::match_results::size return?
  15. C++ – Why is boost::hash_combine the best way to combine hash-values?
  16. Disambiguate class-member in multiple inheritance
  17. In C++, what categories (lvalue, rvalue, xvalue, etc.) can expressions that produce temporaries of class type fall into?
  18. Passing shared pointers as arguments
  19. void_t “can implement concepts”?
  20. Debugging template instantiations
  21. So can unique_ptr be used safely in stl collections?
  22. Compile-time or runtime detection within a constexpr function
  23. Is it possible to declare constexpr class in a header and define it in a separate .cpp file?
  24. Vary range of uniform_int_distribution
  25. What does an ampersand after this assignment operator mean?
  26. Using std::string_view with api that expects null-terminated string
  27. Idiomatic Way to declare C++ Immutable Classes
  28. const auto std::initializer_list difference between Clang and GCC
  29. Workaround for error C2536: cannot specify explicit initializer for arrays in Visual Studio 2013
  30. Is it possible to write an agile Pimpl in c++?

Leave a Comment