La classe `path`

Article
10/12/2023

La path classe stocke un objet de type string_type, appelé myname ici à des fins d’exposition, adapté à une utilisation comme chemin d’accès. string_type est un synonyme pour basic_string<value_type>, où value_type est un synonyme pour wchar_t Windows ou char sur POSIX.

Pour obtenir plus d’informations et des exemples de code, consultez Navigation dans le système de fichiers (C++).

Syntaxe

class path;

Constructeurs

Constructeur	Description
`path`	Construit un objet `path`.

Typedefs

Nom de type	Description
`const_iterator`	Synonyme de `iterator`.
`iterator`	Itérateur de constante bidirectionnelle qui désigne les `path` composants de `myname`.
`string_type`	Le type est un synonyme de `basic_string<value_type>`.

Fonctions Membre

Fonction membre	Description
`append`	Ajoute la séquence spécifiée à `mypath`, convertie et insérée une preferred_separator en fonction des besoins.
`assign`	Remplace par `mypath` la séquence spécifiée, convertie en fonction des besoins.
`begin`	Retourne une `path::iterator` valeur désignant le premier élément de chemin d’accès dans le chemin d’accès, le cas échéant.
`c_str`	Retourne un pointeur vers le premier caractère dans `mypath`.
`clear`	`mypath.clear()`Exécute .
`compare`	Retourne des valeurs de comparaison.
`concat`	Ajoute la séquence spécifiée à `mypath`, convertie (mais pas l’insertion d’un séparateur) selon les besoins.
`empty`	Retourne `mypath.empty()`.
`end`	Retourne un itérateur de fin de séquence de type `iterator`.
`extension`	Retourne le suffixe de `filename()`.
`filename`	Retourne le composant de répertoire racine de `myname`, en particulier `empty() ? path() : *--end()`. Le composant peut être vide.
`generic_string`	Retourne `this->string<Elem, Traits, Alloc>(al)` avec (sous Windows) les barres obliques inverses converties en barres obliques.
`generic_u16string`	Retourne `u16string()` avec (sous Windows) les barres obliques inverses converties en barres obliques.
`generic_u32string`	Retourne `u32string()` avec (sous Windows) les barres obliques inverses converties en barres obliques.
`generic_u8string`	Retourne `u8string()` avec (sous Windows) les barres obliques inverses converties en barres obliques.
`generic_wstring`	Retourne `wstring()` avec (sous Windows) les barres obliques inverses converties en barres obliques.
`has_extension`	Retourne `!extension().empty()`.
`has_filename`	Retourne `!filename().empty()`.
`has_parent_path`	Retourne `!parent_path().empty()`.
`has_relative_path`	Retourne `!relative_path().empty()`.
`has_root_directory`	Retourne `!root_directory().empty()`.
`has_root_name`	Retourne `!root_name().empty()`.
`has_root_path`	Retourne `!root_path().empty()`.
`has_stem`	Retourne `!stem().empty()`.
`is_absolute`	Pour Windows, la fonction retourne `has_root_name() && has_root_directory()`. Pour POSIX, la fonction retourne `has_root_directory()`.
`is_relative`	Retourne `!is_absolute()`.
`make_preferred`	Convertit chaque séparateur en fonction `preferred_separator` des besoins.
`native`	Retourne la représentation native du chemin d’accès.
`parent_path`	Retourne le composant de chemin d’accès parent de `myname`.
`preferred_separator`	L’objet de constante donne le caractère préféré pour la séparation des composants du chemin, en fonction du système d’exploitation hôte.
`relative_path`	Retourne le composant de chemin d’accès relatif de `myname`.
`remove_filename`	Supprime le nom de fichier.
`replace_extension`	Remplace l’extension de `myname`.
`replace_filename`	Remplace le nom de fichier.
`root_directory`	Retourne le composant de répertoire racine de `myname`.
`root_name`	Retourne le composant de nom racine de `myname`.
`root_path`	Retourne le composant de chemin d’accès racine de `myname`.
`stem`	Retourne le `stem` composant de `myname`.
`string`	Convertit la séquence stockée dans `mypath`.
`swap`	`swap(mypath, right.mypath)`Exécute .
`u16string`	Convertit la séquence stockée en `mypath` UTF-16 et la retourne stockée dans un objet de type `u16string`.
`u32string`	Convertit la séquence stockée en `mypath` UTF-32 et la retourne stockée dans un objet de type `u32string`.
`u8string`	Convertit la séquence stockée en `mypath` UTF-8 et la retourne stockée dans un objet de type `u8string`.
`value_type`	Le type décrit les éléments du chemin privilégiés par le système d’exploitation hôte.
`wstring`	Convertit la séquence stockée dans `mypath` l’encodage favorisée par le système hôte pour une `wchar_t` séquence et la renvoie stockée dans un objet de type `wstring`.

Opérateurs

Opérateur	Description
`operator=`	Remplace les éléments du chemin d’accès par une copie d’un autre chemin.
`operator+=`	Différentes `concat` expressions.
`operator/=`	Différentes `append` expressions.
`operator string_type`	Retourne `myname`.

Spécifications

En-tête : <filesystem>

Espace de noms : std::experimental::filesystem

`path::append`

Ajoute la séquence spécifiée à mypath, convertie et insérée selon preferred_separator les besoins.

template <class Source>
path& append(const Source& source);

template <class InIt>
path& append(InIt first, InIt last);

Paramètres

source
Séquence spécifiée.

first
Début de la séquence spécifiée.

last
Fin de la séquence spécifiée.

`path::assign`

Remplace par mypath la séquence spécifiée, convertie en fonction des besoins.

template <class Source>
path& assign(const Source& source);

template <class InIt>
path& assign(InIt first, InIt last);

Paramètres

source
Séquence spécifiée.

first
Début de la séquence spécifiée.

last
Fin de la séquence spécifiée.

`path::begin`

Retourne une path::iterator valeur désignant le premier élément de chemin d’accès dans le chemin d’accès, le cas échéant.

iterator begin() const;

`path::c_str`

Retourne un pointeur vers le premier caractère dans mypath.

const value_type& *c_str() const noexcept;

`path::clear`

mypath.clear()Exécute .

void clear() noexcept;

`path::compare`

La première fonction retourne mypath.compare(pval.native()). La deuxième fonction retourne mypath.compare(str). La troisième fonction retourne mypath.compare(ptr).

int compare(const path& pval) const noexcept;
int compare(const string_type& str) const;
int compare(const value_type *ptr) const;

Paramètres

pval
Chemin d’accès à comparer.

str
Chaîne à comparer.

ptr
Pointeur à comparer.

`path::concat`

Ajoute la séquence spécifiée à mypath, convertie (mais pas l’insertion d’un séparateur) selon les besoins.

template <class Source>
path& concat(const Source& source);

template <class InIt>
path& concat(InIt first, InIt last);

Paramètres

source
Séquence spécifiée.

first
Début de la séquence spécifiée.

last
Fin de la séquence spécifiée.

`path::const_iterator`

Synonyme de iterator.

typedef iterator const_iterator;

`path::empty`

Retourne mypath.empty().

bool empty() const noexcept;

`path::end`

Retourne un itérateur de fin de séquence de type iterator.

iterator end() const;

`path::extension`

Retourne le suffixe de filename().

path extension() const;

Notes

Retourne le suffixe de filename() X telle sorte que :

Si X == path(".") || X == path("..") ou s’il X ne contient aucun point, le suffixe est vide.

Dans le cas contraire, le suffixe commence par (et inclut) le point le plus à droite.

`path::filename`

Retourne le composant de répertoire racine de myname, en particulier empty() path() : *--end(). Le composant peut être vide.

path filename() const;

`path::generic_string`

Retourne this->string<Elem, Traits, Alloc>(al) avec (sous Windows) les barres obliques inverses converties en barres obliques.

template <class Elem,
    class Traits = char_traits<Elem>,
    class Alloc = allocator<Elem>>
  basic_string<Elem, Traits, Alloc>
    generic_string(const Alloc& al = Alloc()) const;

string generic_string() const;

`path::generic_u16string`

Retourne u16string() avec (sous Windows) les barres obliques inverses converties en barres obliques.

u16string generic_u16string() const;

`path::generic_u32string`

Retourne u32string() avec (sous Windows) les barres obliques inverses converties en barres obliques.

u32string generic_u32string() const;

`path::generic_u8string`

Retourne u8string() avec (sous Windows) les barres obliques inverses converties en barres obliques.

string generic_u8string() const;

`path::generic_wstring`

Retourne wstring() avec (sous Windows) les barres obliques inverses converties en barres obliques.

wstring generic_wstring() const;

`path::has_extension`

Retourne !extension().empty().

bool has_extension() const;

`path::has_filename`

Retourne !filename().empty().

bool has_filename() const;

`path::has_parent_path`

Retourne !parent_path().empty().

bool has_parent_path() const;

`path::has_relative_path`

Retourne !relative_path().empty().

bool has_relative_path() const;

`path::has_root_directory`

Retourne !root_directory().empty().

bool has_root_directory() const;

`path::has_root_name`

Retourne !root_name().empty().

bool has_root_name() const;

`path::has_root_path`

Retourne !root_path().empty().

bool has_root_path() const;

`path::has_stem`

Retourne !stem().empty().

bool has_stem() const;

`path::is_absolute`

Pour Windows, la fonction retourne has_root_name() && has_root_directory(). Pour POSIX, la fonction retourne has_root_directory().

bool is_absolute() const;

`path::is_relative`

Retourne !is_absolute().

bool is_relative() const;

`path::iterator`

Itérateur de constante bidirectionnelle qui désigne les composants de chemin d’accès de myname.

class iterator
   {
   // bidirectional iterator for path
   typedef bidirectional_iterator_tag iterator_category;
   typedef path_type value_type;
   typedef ptrdiff_t difference_type;
   typedef const value_type *pointer;
   typedef const value_type& reference;
   // ...
   };

Notes

La classe décrit un itérateur de constante bidirectionnelle qui désigne les path composants de myname la séquence :

le nom de la racine, s’il est présent
le répertoire racine, s’il est présent
les éléments de répertoire restants du parent path, s’ils sont présents, se terminant par le nom de fichier, le cas échéant

Pour pval un objet de type path:

path::iterator X = pval.begin() désigne le premier path élément du chemin d’accès, le cas échéant.
X == pval.end() est true lorsque les X points juste après la fin de la séquence de composants.
*X retourne une chaîne qui correspond au composant actuel
++X désigne le composant suivant dans la séquence, s'il est présent.
--X désigne le composant précédent dans la séquence, s'il est présent.
myname La modification invalide tous les itérateurs désignant des éléments dans myname.

`path::make_preferred`

Convertit chaque séparateur en fonction preferred_separator des besoins.

path& make_preferred();

`path::native`

Obtenez la représentation sous forme de chaîne native du chemin d’accès.

const string_type& native() const noexcept;

Notes

Le chemin d’accès est disponible dans un format générique portable (voir generic_string()) ou dans le format natif du chemin. Cette fonction retourne la chaîne native. Sur un système POSIX, le format générique et le format natif sont identiques.

Dans l’exemple suivant s’exécutant sur Windows 11, la chaîne de chemin générique est c:/t/temp/temp.txt et la chaîne native est c:\\t\\temp.txt

// Compile with /std:c++17 or higher
#include <filesystem>

int main()
{
    std::filesystem::path p(R"(c:\t\temp.txt)");
    auto native = p.native(); // Windows: L"c:\\t\temp.txt"
    auto generic = p.generic_string(); // Windows: "c:/t/temp.txt"
}

`path::operator=`

Remplace les éléments du chemin d’accès par une copie d’un autre chemin.

path& operator=(const path& right);
path& operator=(path&& right) noexcept;

template <class Source>
path& operator=(const Source& source);

Paramètres

right
En path cours de copie dans le path.

source
path source.

Notes

Le premier opérateur membre copie right.myname vers myname. Le deuxième opérateur membre passe right.myname à myname. Le troisième opérateur membre se comporte de la même façon que *this = path(source).

`path::operator+=`

Différentes concat expressions.

path& operator+=(const path& right);
path& operator+=(const string_type& str);
path& operator+=(const value_type *ptr);
path& operator+=(value_type elem);

template <class Source>
path& operator+=(const Source& source);

template <class Elem>
path& operator+=(Elem elem);

Paramètres

right
Chemin d’accès ajouté.

str
Chaîne ajoutée.

ptr
Pointeur ajouté.

elem
value_type Ajout ou Elem.

source
Source ajoutée.

Notes

Les fonctions membres se comportent comme les expressions correspondantes suivantes :

concat(right);
concat(path(str));
concat(ptr);
concat(string_type(1, elem));
concat(source);
concat(path(basic_string<Elem>(1, elem)));

`path::operator/=`

Différentes append expressions.

path& operator/=(const path& right);

template <class Source>
path& operator/=(const Source& source);

Paramètres

right
Chemin d’accès ajouté.

source
Source ajoutée.

Notes

Les fonctions membres se comportent comme les expressions correspondantes suivantes :

append(right);
append(source);

`path::operator string_type`

Retourne myname.

operator string_type() const;

`path::parent_path`

Retourne le composant de chemin d’accès parent de myname.

path parent_path() const;

Notes

Retourne le composant de chemin d’accès parent de myname, en particulier le préfixe d’après myname la suppression filename().native() et tous les séparateurs de répertoires immédiatement précédents. (De même, si begin() != end(), c’est la combinaison de tous les éléments de la plage [begin(), --end()) en appliquant operator/=successivement .) Le composant peut être vide.

`path::path`

Construit de path différentes façons.

path();

path(const path& right);
path(path&& right) noexcept;

template <class Source>
path(const Source& source);

template <class Source>
path(const Source& source, const locale& loc);

template <class InIt>
path(InIt first, InIt last);

template <class InIt>
path(InIt first, InIt last, const locale& loc);

Paramètres

right
Chemin d’accès dont le chemin construit doit être une copie.

source
Source de laquelle le chemin construit doit être une copie.

loc
Paramètres régionaux spécifiés.

first
Position du premier élément à copier.

last
Position du dernier élément à copier.

Notes

Les constructeurs sont tous construits myname de différentes manières :

Pour path() ça, c’est myname().

Pour path(const path& right) c’est myname(right.myname).

Pour path(path&& right) ça, c’est myname(right.myname).

Pour template<class Source> path(const Source& source) ça, c’est myname(source).

Pour template<class Source> path(const Source& source, const locale& loc) cela, myname(source)obtenez toutes les facettes nécessaires codecvt à partir de loc.

Pour template<class InIt> path(InIt first, InIt last) ça, c’est myname(first, last).

Pour template<class InIt> path(InIt first, InIt last, const locale& loc) cela, myname(first, last)obtenez toutes les facettes nécessaires codecvt à partir de loc.

`path::preferred_separator`

L’objet de constante donne le caractère préféré pour la séparation des composants du chemin, en fonction du système d’exploitation hôte.

#if _WIN32_C_LIB
static constexpr value_type preferred_separator == L'\\';
#else // assume POSIX
static constexpr value_type preferred_separator == '/';
#endif // filesystem model now defined

Notes

Il est également permis dans la plupart des contextes sous Windows d’utiliser L'/' à sa place.

`path::relative_path`

Retourne le composant de chemin d’accès relatif de myname.

path relative_path() const;

Notes

Retourne le composant de chemin d’accès relatif de myname, en particulier le suffixe d’après myname la suppression root_path().native() et les séparateurs de répertoires redondants immédiatement suivants. Le composant peut être vide.

`path::remove_filename`

Supprime le nom de fichier.

path& remove_filename();

`path::replace_extension`

Remplace l’extension de myname.

path& replace_extension(const path& newext = path());

Paramètres

newext
Nouvelle extension.

Notes

Supprime d’abord le suffixe extension().native() de myname. Ensuite, si !newext.empty() && newext[0] != dot (où se trouve le point), le point *path(".").c_str()est ajouté à myname. Ensuite newext , il est ajouté à myname.

`path::replace_filename`

Remplace le nom de fichier.

path& replace_filename(const path& pval);

Paramètres

pval
Chemin d’accès du nom de fichier.

Notes

La fonction membre exécute :

remove_filename();

*this /= pval;
return (*this);

`path::root_directory`

Retourne le composant de répertoire racine de myname.

path root_directory() const;

Notes

Le composant peut être vide.

`path::root_name`

Retourne le composant de nom racine de myname.

path root_name() const;

Notes

Le composant peut être vide.

`path::root_path`

Retourne le composant de chemin d’accès racine de myname.

path root_path() const;

Notes

Retourne le composant de chemin d’accès racine de myname, en particulier / root_name()root_directory . Le composant peut être vide.

`path::stem`

Retourne le stem composant de myname.

path stem() const;

Notes

Retourne le stem composant de myname, en particulier filename().native() avec n’importe quelle fin extension().native() supprimée. Le composant peut être vide.

`path::string`

Convertit la séquence stockée dans mypath.

template \<class Elem, class Traits = char_traits\<Elem>, class Alloc = allocator\<Elem>>
basic_string\<Elem, Traits, Alloc> string(const Alloc& al = Alloc()) const;
string string() const;

Notes

La première fonction membre (modèle) convertit la séquence stockée de mypath la même façon que :

string() pour string<char, Traits, Alloc>()
wstring() pour string<wchar_t, Traits, Alloc>()
u16string() pour string<char16_t, Traits, Alloc>()
u32string() pour string<char32_t, Traits, Alloc>()

La deuxième fonction membre convertit la séquence stockée dans mypath l’encodage favorisée par le système hôte pour une char séquence et la retourne stockée dans un objet de type string.

`path::string_type`

Le type est un synonyme de basic_string<value_type>.

typedef basic_string<value_type> string_type;

`path::swap`

swap(mypath, right.mypath)Exécute .

void swap(path& right) noexcept;

`path::u16string`

Convertit la séquence stockée en mypath UTF-16 et la retourne stockée dans un objet de type u16string.

u16string u16string() const;

`path::u32string`

Convertit la séquence stockée en mypath UTF-32 et la retourne stockée dans un objet de type u32string.

u32string u32string() const;

`path::u8string`

Convertit la séquence stockée en mypath UTF-8 et la retourne stockée dans un objet de type u8string.

string u8string() const;

`path::value_type`

Le type décrit les path éléments favorisés par le système d’exploitation hôte.

#if _WIN32_C_LIB
typedef wchar_t value_type;
#else // assume POSIX
typedef char value_type;
#endif // filesystem model now defined

`path::wstring`

Convertit la séquence stockée dans mypath l’encodage favorisée par le système hôte pour une wchar_t séquence et la renvoie stockée dans un objet de type wstring.

wstring wstring() const;

Voir aussi

Informations de référence sur les fichiers d’en-tête

Partager via

La classe path

Syntaxe

Constructeurs

Typedefs

Fonctions Membre

Opérateurs

Spécifications

path::append

Paramètres

path::assign

Paramètres

path::begin

path::c_str

path::clear

path::compare

Paramètres

path::concat

Paramètres

path::const_iterator

path::empty

path::end

path::extension

Notes

path::filename

path::generic_string

path::generic_u16string

path::generic_u32string

path::generic_u8string

path::generic_wstring

path::has_extension

path::has_filename

path::has_parent_path

path::has_relative_path

path::has_root_directory

path::has_root_name

path::has_root_path

path::has_stem

path::is_absolute

path::is_relative

path::iterator

Notes

path::make_preferred

path::native

Notes

path::operator=

Paramètres

Notes

path::operator+=

Paramètres

Notes

path::operator/=

Paramètres

Notes

path::operator string_type

path::parent_path

Notes

path::path

Paramètres

Notes

path::preferred_separator

Notes

path::relative_path

Notes

path::remove_filename

path::replace_extension

Paramètres

Notes

path::replace_filename

Paramètres

Notes

path::root_directory

Notes

path::root_name

Notes

path::root_path

Notes

path::stem

Notes

path::string

La classe `path`

`path::append`

`path::assign`

`path::begin`

`path::c_str`

`path::clear`

`path::compare`

`path::concat`

`path::const_iterator`

`path::empty`

`path::end`

`path::extension`

`path::filename`

`path::generic_string`

`path::generic_u16string`

`path::generic_u32string`

`path::generic_u8string`

`path::generic_wstring`

`path::has_extension`

`path::has_filename`

`path::has_parent_path`

`path::has_relative_path`

`path::has_root_directory`

`path::has_root_name`

`path::has_root_path`

`path::has_stem`

`path::is_absolute`

`path::is_relative`

`path::iterator`

`path::make_preferred`

`path::native`

`path::operator=`

`path::operator+=`

`path::operator/=`

`path::operator string_type`

`path::parent_path`

`path::path`

`path::preferred_separator`

`path::relative_path`

`path::remove_filename`

`path::replace_extension`

`path::replace_filename`

`path::root_directory`

`path::root_name`

`path::root_path`

`path::stem`

`path::string`

`path::string_type`

`path::swap`

`path::u16string`

`path::u32string`

`path::u8string`

`path::value_type`

`path::wstring`