<experimental/filesystem> path, classe

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

Syntax

class path;

Constructors

Typedefs

Fonctions Membre

Operators

Spécifications

En-tête :<experimental/filesystem>

Noms:std::experimental::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);

Parameters

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.

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

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

Parameters

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

Exécute myname.clear().

void clear() noexcept;

path::compare

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

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

Parameters

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);

Parameters

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;

Remarques

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.

Sinon, 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::generic_string

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

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) toutes les barres obliques inverses converties en barre oblique.

u16string generic_u16string() const;

path::generic_u32string

Cette fonction est supprimée dans l’implémentation MSVC historique.

u32string generic_u32string() const = delete;

path::generic_u8string

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

string generic_u8string() const;

path::generic_wstring

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

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;
   // ...
   };

Remarques

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

1. nom racine, le cas échéant

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, le cas échéant.

5. --X désigne le composant précédent dans la séquence, le cas échéant.

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

Remarques

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++14 and _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING defined.
#include <experimental/filesystem>

int main()
{
    std::experimental::filesystem::path p(LR"(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);

Parameters

right
En path cours de copie dans le path.

source
pathSource .

Remarques

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);

Parameters

right
Chemin d’accès ajouté.

str
Chaîne ajoutée.

ptr
Pointeur ajouté.

elem
value_type Ajout ou Elem.

source
Source ajoutée.

Remarques

Les fonctions membres se comportent de la même façon que les expressions correspondantes suivantes :

1. concat(right);

2. concat(path(str));

3. concat(ptr);

4. concat(string_type(1, elem));

5. concat(source);

6. 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);

Parameters

right
Chemin d’accès ajouté.

source
Source ajoutée.

Remarques

Les fonctions membres se comportent de la même façon que 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;

Remarques

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);

Parameters

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.

Remarques

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 constant donne le caractère préféré pour séparer les composants de chemin d’accès, 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

Remarques

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;

Remarques

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());

Parameters

newext
Nouvelle extension.

Remarques

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

path::replace_filename

Remplace le nom de fichier.

path& replace_filename(const path& pval);

Parameters

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

Remarques

La fonction membre s’exécute :

remove_filename();

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

path::root_directory

Retourne le composant de répertoire racine de myname.

path root_directory() const;

Remarques

Le composant peut être vide.

path::root_name

Retourne le composant de nom racine de myname.

path root_name() const;

Remarques

Le composant peut être vide.

path::root_path

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

path root_path() const;

Remarques

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;

Remarques

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;

Remarques

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>()

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

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

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

Cette fonction est supprimée dans l’implémentation MSVC historique.

u32string u32string() const = delete;

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

<experimental/filesystem>
<experimental/filesystem> opérateurs