Namespaces
Variants

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

From 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) (depuis C++17)
template < class Source >
path & operator / = ( const Source & source ) ;
(2) (depuis C++17)
template < class Source >
path & append ( const Source & source ) ;
(3) (depuis C++17)
template < class InputIt >
path & append ( InputIt first, InputIt last ) ;
(4) (depuis C++17)
1) Si p. is_absolute ( ) || ( p. has_root_name ( ) && p. root_name ( ) ! = root_name ( ) ) , alors remplace le chemin actuel par p comme par operator = ( p ) et termine.
* Sinon, si p. has_root_directory ( ) , alors supprime tout répertoire racine et l'intégralité du chemin relatif du format générique du chemin de * this .
* Sinon, si has_filename ( ) || ( ! has_root_directory ( ) && is_absolute ( ) ) , alors ajoute path::preferred_separator au format générique de * this .
* De toute façon, ajoute ensuite le chemin au format natif de p , en omettant tout root-name de son format générique, au format natif de * this . 
// Où "//host" est un nom racine
path("//host")  / "foo" // le résultat est      "//host/foo" (ajoute avec séparateur)
path("//host/") / "foo" // le résultat est aussi "//host/foo" (ajoute sans séparateur)
// Sur POSIX,
path("foo") / ""      // le résultat est "foo/" (ajoute)
path("foo") / "/bar"; // le résultat est "/bar" (remplace)
// Sur Windows,
path("foo") / "C:/bar";  // le résultat est "C:/bar" (remplace)
path("foo") / "C:";      // le résultat est "C:"     (remplace)
path("C:") / "";         // le résultat est "C:"     (ajoute, sans séparateur)
path("C:foo") / "/bar";  // donne "C:/bar"        (supprime le chemin relatif, puis ajoute)
path("C:foo") / "C:bar"; // donne "C:foo/bar"     (ajoute, en omettant le nom racine de p)
2,3) Identique à (1) , mais accepte n'importe quelle std::basic_string , std::basic_string_view , chaîne de caractères multioctets terminée par un caractère nul, ou un itérateur d'entrée pointant vers une séquence de caractères multioctets terminée par un caractère nul. Équivalent à return operator / = ( path ( source ) ) ; .
4) Identique à (1) , mais accepte toute paire d'itérateurs désignant une chaîne multi-caractères. Équivalent à return operator / = ( path ( first, last ) ) ; .

(2) et (3) participent à la résolution de surcharge uniquement si Source et path ne sont pas du même type, et soit :

Table des matières

Paramètres

p - chemin à ajouter
source - std::basic_string , std::basic_string_view , chaîne multicaractère terminée par un caractère nul, ou un itérateur d'entrée pointant vers une séquence multicaractère terminée par un caractère nul, qui représente un nom de chemin (soit en format portable, soit en format natif)
first, last - paire d' LegacyInputIterator s qui spécifient une séquence multicaractère représentant un nom de chemin
Exigences de type
-
InputIt doit satisfaire aux exigences de LegacyInputIterator .
-
Le type de valeur de InputIt doit être l'un des types de caractères encodés ( char , wchar_t , char16_t et char32_t ).

Valeur de retour

* this

Exceptions

Peut lever std:: bad_alloc si l'allocation de mémoire échoue.

Notes

Ces fonctions produisent effectivement une approximation de la signification de l'argument path p dans un environnement où * this est le répertoire de départ.

Exemple

La sortie est produite sur Windows.

Exécuter ce code 
#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';
}

Sortie possible : 

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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Applicable à Comportement publié Comportement corrigé
LWG 3244 C++17 la contrainte que Source ne peut pas être path était manquante ajoutée

Voir aussi

concatène deux chemins sans introduire de séparateur de répertoire
(fonction membre publique)
(C++17)
concatène deux chemins avec un séparateur de répertoire
(fonction)