std::filesystem::path::concat,std::filesystem::path::operator+= (3) - Linux Manuals

std::filesystem::path::concat,std::filesystem::path::operator+=: std::filesystem::path::concat,std::filesystem::path::operator+=


std::filesystem::path::concat,std::filesystem::path::operator+= - std::filesystem::path::concat,std::filesystem::path::operator+=


path& operator+=( const path& p ); (1) (since C++17)
path& operator+=( const string_type& str ); (2) (since C++17)
path& operator+=( std::basic_string_view<value_type> str );
path& operator+=( const value_type* ptr ); (3) (since C++17)
path& operator+=( value_type x ); (4) (since C++17)
template< class Source > (5) (since C++17)
path& operator+=( const Source& source );
template< class CharT > (6) (since C++17)
path& operator+=( CharT x );
template< class Source > (7) (since C++17)
path& concat( const Source& source );
template< class InputIt > (8) (since C++17)
path& concat( InputIterator first, InputIterator last );

Concatenates the current path and the argument
1-7) Appends path(other).native() to the pathname stored in *this in the native format. This directly manipulates the value of native() and may not be portable between operating systems.
8) Same as return *this += path(first, last)


p - path to append
str - string or string view to append
ptr - pointer to the beginning of a null-terminated string to append
x - single character to append
source - std::basic_string, std::basic_string_view, null-terminated multicharacter string, or an input iterator pointing to a null-terminated multicharacter sequence, which represents a path name (either in portable or in native format)
first, last - pair of LegacyInputIterators that specify a multicharacter sequence that represents a path name

Type requirements

InputIt must meet the requirements of LegacyInputIterator.
The value type of InputIt must be one of the encoded character types (char, wchar_t, char16_t and char32_t)
CharT must be one of the encoded character types (char, wchar_t, char16_t and char32_t)

Return value



May throw std::bad_alloc if memory allocation fails.


Unlike with append() or operator/=, additional directory separators are never introduced.


// Run this code

  #include <iostream>
  #include <filesystem>
  namespace fs = std::filesystem;
  int main() {
      fs::path p1; // empty path
      p1 += "var"; // does not insert a separator
      std::cout << "\"\" + \"var\" == " << p1 << '\n';
      p1 += "lib"; // does not insert a separator
      std::cout << "\"\" + \"var\" + \"lib\" == " << p1 << '\n';


  "" + "var" == "var"
  "" + "var" + "lib" == "varlib"

See also

           appends elements to the path with a directory separator
append (public member function)
           concatenates two paths with a directory separator
operator/ (function)