Namespaces
Variants

    std::filesystem::path:: append, std::filesystem::path:: operator/=

    From es.cppreference.net
    C++
    Filesystem library
    Classes
    Functions
    File types
    std::filesystem::path
    Member types
    Member constants
    Member functions
    Path decomposition
    Non-member functions
    (until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
    Helper classes
    path & operator / = ( const path & p ) ;
    		(1) (desde C++17)
    template < class Source >
    path & operator / = ( const Source & source ) ;
    		(2) (desde C++17)
    template < class Source >
    path & append ( const Source & source ) ;
    		(3) (desde C++17)
    template < class InputIt >
    path & append ( InputIt first, InputIt last ) ;
    		(4) (desde C++17)
    1) Si p. is_absolute ( ) || ( p. has_root_name ( ) && p. root_name ( ) ! = root_name ( ) ) , entonces reemplaza la ruta actual con p como si fuera mediante operator = ( p ) y finaliza.
    * De lo contrario, si p. has_root_directory ( ) , entonces elimina cualquier directorio raíz y toda la ruta relativa del formato genérico de ruta de * this .
    * De lo contrario, si has_filename ( ) || ( ! has_root_directory ( ) && is_absolute ( ) ) , entonces añade path::preferred_separator al formato genérico de * this .
    * De cualquier manera, luego agrega el nombre de ruta en formato nativo de p , omitiendo cualquier root-name de su formato genérico, al formato nativo de * this . 
    // Donde "//host" es un root-name
path("//host")  / "foo" // el resultado es      "//host/foo" (añade con separador)
path("//host/") / "foo" // el resultado también es "//host/foo" (añade sin separador)
// En POSIX,
path("foo") / ""      // el resultado es "foo/" (añade)
path("foo") / "/bar"; // el resultado es "/bar" (reemplaza)
// En Windows,
path("foo") / "C:/bar";  // el resultado es "C:/bar" (reemplaza)
path("foo") / "C:";      // el resultado es "C:"     (reemplaza)
path("C:") / "";         // el resultado es "C:"     (añade, sin separador)
path("C:foo") / "/bar";  // produce "C:/bar"        (elimina ruta relativa, luego añade)
path("C:foo") / "C:bar"; // produce "C:foo/bar"     (añade, omitiendo el root-name de p)
    2,3) Igual que (1) , pero acepta cualquier std::basic_string , std::basic_string_view , cadena multibyte terminada en nulo, o un iterador de entrada que apunta a una secuencia multibyte terminada en nulo. Equivalente a return operator / = ( path ( source ) ) ; .
    4) Igual que (1) , pero acepta cualquier par de iteradores que designe una cadena multibyte. Equivalente a return operator / = ( path ( first, last ) ) ; .

    (2) y (3) participan en la resolución de sobrecarga solo si Source y path no son del mismo tipo, y ya sea:

    Contenidos

    Parámetros

    p - nombre de ruta a añadir
    source - std::basic_string , std::basic_string_view , cadena multibyte terminada en nulo, o un iterador de entrada que apunta a una secuencia multibyte terminada en nulo, que representa un nombre de ruta (ya sea en formato portable o nativo)
    first, last - par de LegacyInputIterator s que especifican una secuencia multibyte que representa un nombre de ruta
    Requisitos de tipo
    -
    InputIt debe cumplir con los requisitos de LegacyInputIterator .
    -
    El tipo de valor de InputIt debe ser uno de los tipos de caracteres codificados ( char , wchar_t , char16_t y char32_t ).

    Valor de retorno

    * this

    Excepciones

    Puede lanzar std:: bad_alloc si falla la asignación de memoria.

    Notas

    Estas funciones efectivamente producen una aproximación del significado del argumento de ruta p en un entorno donde * this es el directorio de inicio.

    Ejemplo

    La salida se produce en Windows.

    Ejecutar este código 
    #include <filesystem>
#include <iostream>
namespace fs = std::filesystem;
int main()
{
    fs::path p1 = "C:";
    p1 /= "Users"; // does not insert a separator
    std::cout << "\"C:\" / \"Users\" == " << p1 << '\n';
    p1 /= "batman"; // inserts fs::path::preferred_separator, '\' on Windows
    std::cout << "\"C:\" / \"Users\" / \"batman\" == " << p1 << '\n';
}

    Salida posible: 

    "C:" / "Users" == "C:Users"
"C:" / "Users" / "batman" == "C:Users\\batman"

    Informes de defectos

    Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

    DR Se aplica a Comportamiento publicado Comportamiento correcto
    LWG 3244 C++17 faltaba la restricción de que Source no puede ser path añadida

    Véase también

    		concatena dos rutas sin introducir un separador de directorio
    (función miembro pública)
    (C++17)
    		concatena dos rutas con un separador de directorio
    (función)