Classe path

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.

La path classe décrite ici est la classe C++17 std::filesystem::path dans l’en-tête <filesystem> .

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

Enumerations

Nom de type Description
format Spécifie le format pathname pour les constructeurs : auto_format, native_formatou generic_format.

Fonctions Membre

Fonction membre Description
append Ajoute la séquence spécifiée à myname, convertie et insérée une preferred_separator en fonction des besoins.
assign Remplace par myname 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 myname.
clear myname.clear()Exécute .
compare Retourne des valeurs de comparaison.
concat Ajoute la séquence spécifiée à myname, convertie (mais pas l’insertion d’un séparateur) selon les besoins.
empty Retourne myname.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 nom de fichier 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().
lexically_normal Retourne myname convertie en formulaire normal.
lexically_proximate Retourne lexically_relative(base), ou *this si ce résultat est vide.
lexically_relative Renvoie une valeur myname relative à un chemin d’accès de base, à l’aide de l’analyse lexicale (chaîne) uniquement.
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 myname.
swap swap(myname, right.myname)Exécute .
u16string Convertit la séquence stockée en myname UTF-16 et la retourne stockée dans un objet de type u16string.
u32string Convertit la séquence stockée en myname UTF-32 et la retourne stockée dans un objet de type u32string.
u8string Convertit la séquence stockée en myname 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 myname 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::filesystem

path::append

Ajoute la séquence spécifiée à myname, 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 myname la séquence spécifiée, convertie en fonction des besoins.

path& assign(string_type&& source);

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

const value_type* c_str() const noexcept;

path::clear

myname.clear()Exécute .

void clear() noexcept;

path::compare

La première fonction compare les éléments de ce chemin d’accès à pval. Les autres fonctions construisent un chemin d’accès à partir de leur argument et retournent le résultat de la comparaison avec ce chemin.

int compare(const path& pval) const noexcept;
int compare(const string_type& str) const;
int compare(basic_string_view<value_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 à myname, 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 myname.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 nom de fichier de myname, en particulier empty() ? path() : *--end(). Le composant peut être vide.

path filename() const;

path::format

Spécifie le format pathname utilisé pour interpréter la séquence de caractères passée à un path constructeur.

enum format {
    auto_format,
    native_format,
    generic_format
};

Members

Énumérateur Description
auto_format L’implémentation détecte automatiquement le format. Il s’agit de la valeur par défaut pour les constructeurs qui prennent un format argument.
native_format Interpréter la séquence au format de chemin d’accès natif.
generic_format Interpréter la séquence au format générique pathname.

Notes

Étant donné que le format natif et le format générique sont interchangeables sur Windows, l’implémentation Microsoft traite les trois énumérateurs identiques. Le format paramètre est fourni pour la conformité et la portabilité standard. Pour plus d’informations, consultez la spécification WG21 N4659 [fs.class.path].

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 :

  1. le nom de la racine, s’il est présent

  2. le répertoire racine, s’il est présent

  3. 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:

  1. path::iterator X = pval.begin() désigne le premier path élément du chemin d’accès, le cas échéant.

  2. X == pval.end() est true lorsque les X points juste après la fin de la séquence de composants.

  3. *X retourne une chaîne qui correspond au composant actuel

  4. ++X désigne le composant suivant dans la séquence, s'il est présent.

  5. --X désigne le composant précédent dans la séquence, s'il est présent.

  6. myname La modification invalide tous les itérateurs désignant des éléments dans myname.

path::lexically_normal

Retourne myname convertie en formulaire normal. La conversion est purement lexicale : le système de fichiers n’est pas accessible.

path lexically_normal() const;

Notes

La normalisation réduit les éléments redondants tels que . et .. les séparateurs de répertoires. Par exemple, path("a/./b/../c").lexically_normal() les rendements a\c sur Windows. Un chemin vide normalise vers un chemin vide ; un chemin qui se réduit à rien normalise à .. Pour obtenir l’algorithme de normalisation complet, consultez la spécification WG21 N4659 [fs.path.generic].

path::lexically_proximate

Retourne le résultat de lexically_relative(base). Si ce résultat est un chemin vide, retourne plutôt une copie.*this

path lexically_proximate(const path& base) const;

Paramètres

base
Chemin d’accès de base vers lequel *this effectuer une proximité.

path::lexically_relative

Renvoie une valeur myname relative à base, à l’aide de l’analyse lexicale (chaîne) uniquement. Le système de fichiers n’est pas accessible.

path lexically_relative(const path& base) const;

Paramètres

base
Chemin d’accès de base à effectuer *this par rapport à.

Notes

Si root_name() != base.root_name(), ou si un chemin est absolu et que l’autre est relatif, ou si le chemin possède un nom de fichier mais qu’aucun répertoire racine n’est utilisé pendant que la base ne le fait pas, retourne un chemin vide. Sinon, détermine le chemin d’accès base relatif de vers en *this recherchant le premier élément incompatible et en émettant .. pour chaque élément restant de base, suivi des éléments restants de *this. Par exemple, path("/a/d").lexically_relative("/a/b/c") donne ..\..\d. Pour obtenir l’algorithme complet, consultez la spécification WG21 N4659 [fs.path.gen].

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, la chaîne de chemin générique est c:/t/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;
path& operator=(string_type&& source);

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 passe source en myname. Le quatriè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+=(basic_string_view<value_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 de la même façon que l’appel concat avec l’argument. Les pathsurcharges terminées par la valeur , string_typeet basic_string_viewnull value_type* concatènent la séquence de caractères de l’argument. Les value_type surcharges concatènent Elem un caractère unique. La surcharge modèle Source concatène la séquence source convertie.

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 :

  1. append(right);

  2. 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() noexcept;

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

path(string_type&& source, format fmt = auto_format);

template <class Source>
path(const Source& source, format fmt = auto_format);

template <class InIt>
path(InIt first, InIt last, format fmt = auto_format);

template <class Source>
path(const Source& source, const locale& loc, format fmt = auto_format);

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

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.

fmt
Nom de chemin format utilisé pour interpréter source ou la first/last plage. La valeur par défaut est auto_format.

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) ça, c’est myname(right.myname).

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

Pour path(string_type&& source, format fmt) ça, c’est myname(move(source)).

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

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

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

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

Le fmt paramètre sélectionne le format pathname. Sur Windows, les formats natifs et génériques sont interchangeablesfmt, de sorte que l’implémentation Microsoft ignore .

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ù *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 particulierroot_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 myname.

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 myname la même façon que :

  1. string() pour string<char, Traits, Alloc>()

  2. wstring() pour string<wchar_t, Traits, Alloc>()

  3. u16string() pour string<char16_t, Traits, Alloc>()

  4. u32string() pour string<char32_t, Traits, Alloc>()

La deuxième fonction membre convertit la séquence stockée dans myname 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(myname, right.myname)Exécute .

void swap(path& right) noexcept;

path::u16string

Convertit la séquence stockée en myname 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 myname 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 myname 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 myname 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

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

  • Dernière mise à jour :