##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::filesystem::path::lexically_normal, std::filesystem::path::lexically_relative, std::filesystem::path::lexically_proximate

From cppreference.com
< cpp‎ | filesystem‎ | path

path lexically_normal() const; | (1) | (since C++17)
path lexically_relative(const path& base) const; | (2) | (since C++17)
path lexically_proximate(const path& base) const; | (3) | (since C++17)

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, first, determines the first mismatched element of `*this` and `base` as if by auto [a, b] = mismatch(begin(), end(), base.begin(), base.end()), then

  - if a == begin() and b == base.begin(), returns path() (empty path).
  - otherwise, if a == end() and b == base.end(), returns path(".");
  - otherwise returns an object composed from a default-constructed path() followed by one application of operator/=(path("..")) for each each element in the half-open range `[b, base.end())`, and then by one application of operator/= for each element in the half-open range `[a, end())`.

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

### [edit] Parameters

(none)

### [edit] Return value

1) The normal form of the path
2) The relative form of the path
3) The proximate form of the path

### [edit] Exceptions

(none)

### [edit] Notes

These conversions are purely lexical. They do not check that the paths exist, do not follow symlinks, and do not access the filesystem at all. For symlink-following counterparts of `lexically_relative` and `lexically_proximate`, see `relative` and `proximate`.

On Windows, the returned path has backslashes (the preferred separators),

### [edit] Example

Run this code

    #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") == "");
    }

### [edit] See also

relative proximate (C++17) | composes a relative path (function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/filesystem/path/lexically_normal&oldid=88310"