29 Input/output library [input.output]

29.11 File systems [filesystems]

29.11.7 Class path [fs.class.path]

29.11.7.4 Members [fs.path.member]

29.11.7.4.11 Generation [fs.path.gen]

🔗
path lexically_normal() const;
1
#
Returns: A path whose pathname in the generic format is the normal form ([fs.path.generic]) of the pathname in the generic format of *this.
2
#
[ Example
: 
assert(path("foo/./bar/..").lexically_normal() == "foo/");
assert(path("foo/.///bar/../").lexically_normal() == "foo/");
The above assertions will succeed.
On Windows, the returned path's directory-separator characters will be backslashes rather than slashes, but that does not affect path equality.
— end example
 ]
🔗
path lexically_relative(const path& base) const;
3
#
Returns: *this made relative to base.
Does not resolve ([fs.class.path]) symlinks.
Does not first normalize ([fs.path.generic]) *this or base.
4
#
Effects: If:
  • (4.1)
    root_­name() != base.root_­name() is true, or
  • (4.2)
    is_­absolute() != base.is_­absolute() is true, or
  • (4.3)
    !has_­root_­directory() && base.has_­root_­directory() is true, or
  • (4.4)
    any filename in relative_­path() or base.relative_­path() can be interpreted as a root-name,
returns path().
[ Note
:
On a POSIX implementation, no filename in a relative-path is acceptable as a root-name.
— end note
 ]
Determines the first mismatched element of *this and base as if by: 
auto [a, b] = mismatch(begin(), end(), base.begin(), base.end());
Then,
  • (4.5)
    if a == end() and b == base.end(), returns path("."); otherwise
  • (4.6)
    let n be the number of filename elements in [b, base.end()) that are not dot or dot-dot or empty, minus the number that are dot-dot. If n<0, returns path(); otherwise
  • (4.7)
    if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
  • (4.8)
    returns an object of class path that is default-constructed, followed by
    • (4.8.1)
      application of operator/=(path("..")) n times, and then
    • (4.8.2)
      application of operator/= for each element in [a, end()).
5
#
[ Example
: 
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") == "../../a/b");
The above assertions will succeed.
On Windows, the returned path's directory-separator characters will be backslashes rather than slashes, but that does not affect path equality.
— end example
 ]
6
#
[ Note
:
If symlink following semantics are desired, use the operational function relative().
— end note
 ]
7
#
[ Note
:
If normalization ([fs.path.generic]) is needed to ensure consistent matching of elements, apply lexically_­normal() to *this, base, or both.
— end note
 ]
🔗
path lexically_proximate(const path& base) const;
8
#
Returns: If the value of lexically_­relative(base) is not an empty path, return it.
Otherwise return *this.
9
#
[ Note
:
If symlink following semantics are desired, use the operational function proximate().
— end note
 ]
10
#
[ Note
:
If normalization ([fs.path.generic]) is needed to ensure consistent matching of elements, apply lexically_­normal() to *this, base, or both.
— end note
 ]