path klass

Klassen path lagrar ett objekt av typen string_type, som anropas myname här för exposition, som är lämpligt för användning som sökvägsnamn. string_typeär en synonym för basic_string<value_type>, där value_type är en synonym för wchar_t på Windows eller char på POSIX.

Klassen path som beskrivs här är klassen C++17 std::filesystem::path i <filesystem> rubriken.

Mer information och kodexempel finns i Filsystemnavigering (C++).

Syntax

class path;

Constructors

Typedefs

Enumerations

Medlemsfunktioner

Operators

Requirements

rubrik:<filesystem>

Namnområde:std::filesystem

path::append

Lägger till den angivna sekvensen i myname, konverteras och infogar en preferred_separator efter behov.

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

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

Parameters

source
Angiven sekvens.

first
Start av angiven sekvens.

last
Slutet av den angivna sekvensen.

path::assign

myname Ersätter med den angivna sekvensen, konverterad efter behov.

path& assign(string_type&& source);

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

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

Parameters

source
Angiven sekvens.

first
Start av angiven sekvens.

last
Slutet av den angivna sekvensen.

path::begin

Returnerar ett path::iterator som anger det första sökvägselementet i pathname, om det finns.

iterator begin() const;

path::c_str

Returnerar en pekare till det första tecknet i myname.

const value_type* c_str() const noexcept;

path::clear

myname.clear()Kör .

void clear() noexcept;

path::compare

Den första funktionen jämför elementen i den här sökvägen med pval. De andra funktionerna konstruerar en sökväg från argumentet och returnerar resultatet av att jämföra den med den här sökvägen.

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;

Parameters

pval
Sökväg att jämföra.

str
Sträng att jämföra.

ptr
Pekare att jämföra.

path::concat

Lägger till den angivna sekvensen i myname, konverterad (men infogar inte en avgränsare) efter behov.

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

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

Parameters

source
Angiven sekvens.

first
Start av angiven sekvens.

last
Slutet av den angivna sekvensen.

path::const_iterator

En synonym för iterator.

typedef iterator const_iterator;

path::empty

Returnerar myname.empty().

bool empty() const noexcept;

path::end

Returnerar en iterator i slutet av sekvensen av typen iterator.

iterator end() const;

path::extension

Returnerar suffixet filename()för .

path extension() const;

Kommentarer

Returnerar suffixet filename() X för så här:

Om X == path(".") || X == path("..") eller om X det inte innehåller någon punkt är suffixet tomt.

Annars börjar suffixet med (och innehåller) den högra punkten.

path::filename

Returnerar filnamnskomponenten mynameför , specifikt empty() ? path() : *--end(). Komponenten kan vara tom.

path filename() const;

path::format

Anger det pathname-format som används för att tolka teckensekvensen som skickas till en path konstruktor.

enum format {
    auto_format,
    native_format,
    generic_format
};

Members

Kommentarer

Eftersom det inbyggda formatet och det generiska formatet är utbytbara på Windows behandlar Microsoft-implementeringen alla tre uppräknaren på samma sätt. Parametern format tillhandahålls för standardefterlevnad och portabilitet. Mer information finns i specifikationen WG21 N4659 [fs.class.path].

path::generic_string

Returnerar this->string<Elem, Traits, Alloc>(al) med (under Windows) eventuella omvänt snedstreck konverterade till ett snedstreck.

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

Returnerar u16string() med (under Windows) eventuella omvänt snedstreck konverterade till ett snedstreck.

u16string generic_u16string() const;

path::generic_u32string

Returnerar u32string() med (under Windows) eventuella omvänt snedstreck konverterade till ett snedstreck.

u32string generic_u32string() const;

path::generic_u8string

Returnerar u8string() med (under Windows) eventuella omvänt snedstreck konverterade till ett snedstreck.

string generic_u8string() const;

path::generic_wstring

Returnerar wstring() med (under Windows) eventuella omvänt snedstreck konverterade till ett snedstreck.

wstring generic_wstring() const;

path::has_extension

Returnerar !extension().empty().

bool has_extension() const;

path::has_filename

Returnerar !filename().empty().

bool has_filename() const;

path::has_parent_path

Returnerar !parent_path().empty().

bool has_parent_path() const;

path::has_relative_path

Returnerar !relative_path().empty().

bool has_relative_path() const;

path::has_root_directory

Returnerar !root_directory().empty().

bool has_root_directory() const;

path::has_root_name

Returnerar !root_name().empty().

bool has_root_name() const;

path::has_root_path

Returnerar !root_path().empty().

bool has_root_path() const;

path::has_stem

Returnerar !stem().empty().

bool has_stem() const;

path::is_absolute

För Windows returnerar has_root_name() && has_root_directory()funktionen . För POSIX returnerar has_root_directory()funktionen .

bool is_absolute() const;

path::is_relative

Returnerar !is_absolute().

bool is_relative() const;

path::iterator

En dubbelriktad konstant iterator som anger sökvägskomponenterna mynamei .

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

Kommentarer

Klassen beskriver en dubbelriktad konstant iterator som anger komponenterna pathmyname i i sekvensen:

1. rotnamnet, om det finns

2. rotkatalogen, om den finns

3. återstående katalogelement i det överordnade path, om det finns, som slutar med filnamnet, om det finns

För pval ett objekt av typen path:

1. path::iterator X = pval.begin() anger det första path elementet i pathname, om det finns.

2. X == pval.end() är true när X pekar precis förbi slutet av sekvensen av komponenter.

3. *X returnerar en sträng som matchar den aktuella komponenten

4. ++X anger nästa komponent i sekvensen, om den finns.

5. --X anger den föregående komponenten i sekvensen, om den finns.

6. Om du ändrar myname ogiltigförklaras alla iteratorer som anger element i myname.

path::lexically_normal

Returnerar myname konverterat till normalt formulär. Konverteringen är rent lexikal: filsystemet används inte.

path lexically_normal() const;

Kommentarer

Normaliseringen döljer redundanta element som . och .. och katalogavgränsare. Till exempel path("a/./b/../c").lexically_normal() ger avkastning a\c på Windows. En tom sökväg normaliseras till en tom sökväg. en sökväg som reducerar till ingenting normaliserar till .. Den fullständiga normaliseringsalgoritmen finns i specifikationen WG21 N4659 [fs.path.generic].

path::lexically_proximate

Returnerar resultatet av lexically_relative(base). Om resultatet är en tom sökväg returnerar du en kopia av *this i stället.

path lexically_proximate(const path& base) const;

Parameters

base
Basvägen att göra *this proximate till.

path::lexically_relative

Returnerar myname som gjorts i förhållande till base, endast med hjälp av lexikal analys (sträng). Filsystemet används inte.

path lexically_relative(const path& base) const;

Parameters

base
Den bassökväg som ska upprättas *this i förhållande till.

Kommentarer

Om root_name() != base.root_name(), eller om den ena sökvägen är absolut och den andra är relativ, eller om sökvägen har ett filnamn men ingen rotkatalog medan basen inte gör det, returnerar en tom sökväg. I annat fall avgör den relativa sökvägen från base till genom att *this hitta det första felmatchade elementet och generera .. för varje återstående element i base, följt av de återstående elementen *thisi . Till exempel path("/a/d").lexically_relative("/a/b/c") ger ..\..\d. Den fullständiga algoritmen finns i specifikationen WG21 N4659 [fs.path.gen].

path::make_preferred

Konverterar varje avgränsare till en preferred_separator efter behov.

path& make_preferred();

path::native

Hämta den interna strängrepresentationen av sökvägen.

const string_type& native() const noexcept;

Kommentarer

Sökvägen är tillgänglig i ett portabelt generiskt format (se generic_string()) eller sökvägens interna format. Den här funktionen returnerar den inbyggda strängen. I ett POSIX-system är det allmänna formatet och det interna formatet samma.

I följande exempel som körs på Windows är c:/t/temp.txt den allmänna sökvägssträngen och den inbyggda strängen .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=

Ersätter elementen i sökvägen med en kopia av en annan sökväg.

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

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

Parameters

right
Som path kopieras till path.

source
Källan path.

Kommentarer

Den första medlemsoperatorn kopieras right.myname till myname. Den andra medlemsoperatorn flyttas right.myname till myname. Den tredje medlemsoperatorn flyttas source till myname. Den fjärde medlemsoperatorn beter sig på samma sätt som *this = path(source).

path::operator+=

Olika concat uttryck.

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

Parameters

right
Den tillagda sökvägen.

str
Den tillagda strängen.

ptr
Den tillagda pekaren.

elem
Den tillagda value_type eller Elem.

source
Den tillagda källan.

Kommentarer

Medlemsfunktionerna beter sig på samma sätt som anropet concat med argumentet. Överlagringarna path, string_type, basic_string_viewoch null-avslutade value_type* sammanlänkar argumentets teckensekvens. Överlagringarna value_type och Elem sammanfogar ett enda tecken. Den mallade Source överlagringen sammanfogar den konverterade källsekvensen.

path::operator/=

Olika append uttryck.

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

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

Parameters

right
Den tillagda sökvägen.

source
Den tillagda källan.

Kommentarer

Medlemsfunktionerna fungerar på samma sätt som följande motsvarande uttryck:

1. append(right);

2. append(source);

path::operator string_type

Returnerar myname.

operator string_type() const;

path::parent_path

Returnerar komponenten mynameför den överordnade sökvägen i .

path parent_path() const;

Kommentarer

Returnerar den överordnade sökvägskomponenten mynameför , specifikt prefixet myname för efter borttagning filename().native() och eventuella direkt föregående katalogavgränsare. (På samma sätt, om begin() != end(), är det kombinationen av alla element i intervallet [begin(), --end()) genom att successivt tillämpa operator/=.) Komponenten kan vara tom.

path::path

Konstruerar en path på olika sätt.

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

Parameters

right
Sökvägen till vilken den konstruerade sökvägen ska vara en kopia.

source
Källan som den konstruerade sökvägen ska vara en kopia av.

fmt
Det sökvägsnamn format som används för att tolka source eller intervallet first/last . Standardinställningen är auto_format.

loc
Det angivna språket.

first
Positionen för det första element som ska kopieras.

last
Positionen för det sista element som ska kopieras.

Kommentarer

Konstruktorerna konstruerar myname alla på olika sätt:

För path() det är myname().

För path(const path& right) det är myname(right.myname).

För path(path&& right) det är myname(right.myname).

För path(string_type&& source, format fmt) det är myname(move(source)).

För template<class Source> path(const Source& source, format fmt) det är myname(source).

För template<class Source> path(const Source& source, const locale& loc, format fmt) det är myname(source)hämtar du alla nödvändiga codecvt fasetter från loc.

För template<class InIt> path(InIt first, InIt last, format fmt) det är myname(first, last).

För template<class InIt> path(InIt first, InIt last, const locale& loc, format fmt) det är myname(first, last)hämtar du alla nödvändiga codecvt fasetter från loc.

Parametern fmt väljer pathname-formatet. På Windows är de inbyggda och generiska formaten utbytbara, så Microsoft implementeringen ignorerar fmt.

path::preferred_separator

Det konstanta objektet ger det föredragna tecknet för att avgränsa sökvägskomponenter, beroende på värdoperativsystemet.

#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

Kommentarer

Det är lika tillåtet i de flesta sammanhang under Windows att använda L'/' i dess ställe.

path::relative_path

Returnerar komponenten mynamerelativ sökväg i .

path relative_path() const;

Kommentarer

Returnerar den relativa sökvägskomponenten mynamei , specifikt suffixet myname för efter borttagning root_path().native() och eventuella omedelbart efterföljande redundanta katalogavgränsare. Komponenten kan vara tom.

path::remove_filename

Tar bort filnamnet.

path& remove_filename();

path::replace_extension

Ersätter tillägget mynameför .

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

Parameters

newext
Det nya tillägget.

Kommentarer

Tar först bort suffixet extension().native() från myname. !newext.empty() && newext[0] != dot Om (där punkt är *path(".").c_str()) läggs sedan punkt till i myname. Läggs sedan newext till mynamei .

path::replace_filename

Ersätter filnamnet.

path& replace_filename(const path& pval);

Parameters

pval
Sökvägen till filnamnet.

Kommentarer

Medlemsfunktionen kör:

remove_filename();

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

path::root_directory

Returnerar rotkatalogkomponenten mynamei .

path root_directory() const;

Kommentarer

Komponenten kan vara tom.

path::root_name

Returnerar rotnamnskomponenten mynameför .

path root_name() const;

Kommentarer

Komponenten kan vara tom.

path::root_path

Returnerar rotsökvägskomponenten i myname.

path root_path() const;

Kommentarer

Returnerar rotsökvägskomponenten mynameför , specifikt / root_name()root_directory . Komponenten kan vara tom.

path::stem

Returnerar komponenten mynamei stem .

path stem() const;

Kommentarer

Returnerar komponenten mynamei stem , specifikt filename().native() med eventuella avslutande borttagnaextension().native(). Komponenten kan vara tom.

path::string

Konverterar sekvensen som lagras i 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;

Kommentarer

Den första medlemsfunktionen (mall) konverterar sekvensen som lagras på myname samma sätt som:

1. string() för string<char, Traits, Alloc>()

2. wstring() för string<wchar_t, Traits, Alloc>()

3. u16string() för string<char16_t, Traits, Alloc>()

4. u32string() för string<char32_t, Traits, Alloc>()

Den andra medlemsfunktionen konverterar sekvensen som lagras i myname till den kodning som värdsystemet föredrar för en char sekvens och returnerar den lagrad i ett objekt av typen string.

path::string_type

Typen är en synonym för basic_string<value_type>.

typedef basic_string<value_type> string_type;

path::swap

swap(myname, right.myname)Kör .

void swap(path& right) noexcept;

path::u16string

Konverterar sekvensen som lagras i myname till UTF-16 och returnerar den lagrad i ett objekt av typen u16string.

u16string u16string() const;

path::u32string

Konverterar sekvensen som lagras i myname till UTF-32 och returnerar den lagrad i ett objekt av typen u32string.

u32string u32string() const;

path::u8string

Konverterar sekvensen som lagras i myname till UTF-8 och returnerar den lagrad i ett objekt av typen u8string.

string u8string() const;

path::value_type

Typen beskriver de path element som gynnas av värdoperativsystemet.

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

path::wstring

Konverterar sekvensen som lagras i myname till den kodning som värdsystemet föredrar för en wchar_t sekvens och returnerar den lagrad i ett objekt av typen wstring.

wstring wstring() const;

Se även

<filesystem>
referens för huvudfiler