path lexically_normal() const;

path lexically_relative(const path& base) const;

path lexically_proximate(const path& base) const;

1) Returns *this converted to normal form (no redundant dot or dot-dot elements, and if the last element is a non-root directory separator, dot is added)

2) Returns *this made relative to base. Effectively does the following:

First, determines the first mismatched element of *this and base using std::mismatch(begin(), end(), base.begin(), base.end()), then.

• if the first mismatched element of *this is equal to begin() or the first mismatched element of base is equal to base.begin(), returns path() (empty path).
• otherwise, if the first mismatched element of *this is equal to end() and the first mismatched element of base is equal to base.end(), returns path(".")
• otherwise returns an object of class path composed via application of operator/=(path("..")) for each element in the half-open range [first mismatched element of base, base.end()), and then application of for each element in the half-open range [first mismatched element of *this, end()).

3) If the value of lexically_relative(base) is not an empty path, return it. Otherwise return *this.

1) The normal form of the path

2) The relative form of the path

3) The proximate form of the path

#include <iostream>
#include <filesystem>
#include <cassert>
namespace fs = std::filesystem;
 
int main()
{
    assert(fs::path("foo/./bar/..").lexically_normal() == "foo");
    assert(fs::path("foo/.///bar/../").lexically_normal() == "foo/.");
 
    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") == "");
}