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

> C++ Atlas: `cppatlas.com/w/cpp/experimental/fs/absolute` | Source: https://en.cppreference.com/w/cpp/experimental/fs/absolute | Domain: Technical specifications

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

## Official Specification Summary (cppreference)

```cpp
// Defined in header <experimental/filesystem>

path absolute( const path& p, const path& base = current_path() ); // (1) (filesystem TS)

path system_complete( const path& p );
path system_complete( const path& p, error_code& ec ); // (2) (filesystem TS)
```

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() / fs::absolute(base).root_directory() / fs::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, `fs::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` (`fs::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.

### 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

### Return value

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

### Exceptions

The overload that does not take an

`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 an

`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`

### 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.

### Example

```cpp
#include <filesystem>
#include <iostream>
namespace fs = std::experimental::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:

```text
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"
```

### See also

- [`canonical`](https://en.cppreference.com/w/cpp/experimental/fs/canonical): composes a canonical path (function)

---
Attribution: content from https://en.cppreference.com/w/cpp/experimental/fs/absolute (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.