std::filesystem::absolute, std::filesystem::system_complete - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::filesystem::absolute, std::filesystem::system_complete

From cppreference.com
< cpp‎ | filesystem

Defined in header `<filesystem>` |  |
path absolute( const std::filesystem::path& p, const std::filesystem::path& base = std::filesystem::current_path() ); | (1) | (since C++17)
path system_complete(const std::filesystem::path& p); path system_complete(const std::filesystem::path& p, std::error_code& ec); | (2) | (since C++17)

1) Returns absolute path of `p` relative to `base` according to the following rules:

  - If `p` has both root name and root directory (e.g. "C:\users", then the path is returned, unmodified.
  - If `p` has a root name not followed by a root directory (e.g. "C:text.txt"), then `base` is inserted between `p`'s root name and the remainder of `p`. Formally, p.root_name() / absolute(base).root_directory() / absolute(base).relative_path() / p.relative_path() is returned,
  - If `p` has no root name, but has a root directory (e.g. "/var/tmp/file.txt" on a POSIX system or "\users\ABC\Document.doc" on Windows), then the root name of `base`, if it has one, is prepended to `p` (on a POSIX system, `p` is not modified, on a Windows system, "\users\ABC\Document.doc" becomes "C:\users\ABC\Document.doc". Formally, absolute(base).root_name() / p is returned.
  - If `p` has no root name and no root directory (e.g. "../file.txt", then the entire `base` is prepended to `p`. Formally, absolute(base) / p is returned.

2) Obtains the absolute path that identifies the file that the OS file opening API would access given the pathname `p`. On POSIX systems, this is equivalent to (1) with the default `base` (`current_path()`). On Windows systems, each logical drive has its own current working directory, and so if `p` is not already absolute and has a root name component (e.g. "E:filename.txt", that drive's current working directory is used, which may have been set by an earlier executed program.

### [edit] Parameters

p | - | path to convert to absolute form
base | - | path (not necessarily absolute) to serve as the starting location
ec | - | out-parameter for error reporting in the non-throwing overload

### [edit] Return value

Returns an absolute (although not necessarily canonical) path formed by combining `p` and `base` as described above.

### [edit] Exceptions

The overload that does not take a std::error_code& parameter throws filesystem_error on underlying OS API errors, constructed with `p` as the first argument, `base` as the second argument, and the OS error code as the error code argument. std::bad_alloc may be thrown if memory allocation fails. The overload taking a std::error_code& parameter sets it to the OS API error code if an OS API call fails, and executes ec.clear() if no errors occur. This overload has
`noexcept` specification:
noexcept

### [edit] Notes

On systems that support root names (e.g. Windows), the result of calling `absolute` on a relative path that has a root name (e.g. "D:file.txt" when the root name of `base` is different will usually result in a non-existent path.

### [edit] Example

Run this code

    #include <iostream>
    #include <filesystem>
    namespace fs = std::filesystem;
    int main()
    {
        fs::path p = "C:cl.exe";
        std::cout << "Current path is " << fs::current_path() << '\n'
                  << "Absolute path for " << p << " is " << fs::absolute(p) << '\n'
    	      << "System complete path for " << p << " is " << fs::system_complete(p) << '\n';
    }

Possible output:

    Current path is "D:/local/ConsoleApplication1"
    Absolute path for "C:cl.exe" is "C:/local/ConsoleApplication1/cl.exe"
    System complete path for "C:cl.exe" is "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\cl.exe"

### [edit] See also

canonicalweakly_canonical (C++17) | composes a canonical path (function) [edit]
relativeproximate (C++17) | composes a relative path (function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/filesystem/absolute&oldid=90207"
Category:

- unconditionally noexcept

Hidden categories:

- Pages with unreviewed unconditional noexcept template
- Pages with unreviewed noexcept template