`path` Třída

Článek
10/12/2023

Třída path ukládá objekt typu string_type, volaný myname zde pro účely expozice, vhodné pro použití jako název cesty. string_type je synonymem pro basic_string<value_type>, kde value_type je synonymem pro wchar_t Windows nebo char POSIX.

Další informace a příklady kódu najdete v tématu Navigace v systému souborů (C++).

Syntaxe

class path;

Konstruktory

Konstruktor	Popis
`path`	Vytvoří .`path`

Typedefs

Název typu	Popis
`const_iterator`	Synonymum pro `iterator`.
`iterator`	Obousměrný konstantní iterátor, který určuje `path` součásti `myname`.
`string_type`	Typ je synonymem pro `basic_string<value_type>`.

Členské funkce

Členová funkce	Popis
`append`	Připojí zadanou sekvenci k `mypath`převedené a vložení preferred_separator podle potřeby.
`assign`	`mypath` Nahradí zadanou sekvencí převedenou podle potřeby.
`begin`	`path::iterator` Vrátí označení prvního prvku cesty v pathname, pokud je k dispozici.
`c_str`	Vrátí ukazatel na první znak v argumentu `mypath`.
`clear`	`mypath.clear()`Spustí .
`compare`	Vrátí hodnoty porovnání.
`concat`	Připojí zadanou sekvenci k `mypath`převedené (ale ne vložení oddělovače) podle potřeby.
`empty`	Vrací objekt `mypath.empty()`.
`end`	Vrátí iterátor typu `iterator`end-of-sequence .
`extension`	Vrátí příponu .`filename()`
`filename`	Vrátí kořenovou složku `myname`adresáře , konkrétně `empty() ? path() : *--end()`. Komponenta může být prázdná.
`generic_string`	Vrátí všechny `this->string<Elem, Traits, Alloc>(al)` zpětné lomítko převedené na lomítko (v systému Windows).
`generic_u16string`	Vrátí všechny `u16string()` zpětné lomítko převedené na lomítko (v systému Windows).
`generic_u32string`	Vrátí všechny `u32string()` zpětné lomítko převedené na lomítko (v systému Windows).
`generic_u8string`	Vrátí všechny `u8string()` zpětné lomítko převedené na lomítko (v systému Windows).
`generic_wstring`	Vrátí všechny `wstring()` zpětné lomítko převedené na lomítko (v systému Windows).
`has_extension`	Vrací objekt `!extension().empty()`.
`has_filename`	Vrací objekt `!filename().empty()`.
`has_parent_path`	Vrací objekt `!parent_path().empty()`.
`has_relative_path`	Vrací objekt `!relative_path().empty()`.
`has_root_directory`	Vrací objekt `!root_directory().empty()`.
`has_root_name`	Vrací objekt `!root_name().empty()`.
`has_root_path`	Vrací objekt `!root_path().empty()`.
`has_stem`	Vrací objekt `!stem().empty()`.
`is_absolute`	Pro Windows funkce vrátí `has_root_name() && has_root_directory()`. Pro POSIX vrátí `has_root_directory()`funkce .
`is_relative`	Vrací objekt `!is_absolute()`.
`make_preferred`	Převede každý oddělovač podle potřeby na požadovaný `preferred_separator` .
`native`	Vrátí nativní reprezentaci cesty.
`parent_path`	Vrátí nadřazenou komponentu `myname`cesty .
`preferred_separator`	Konstantní objekt dává upřednostňovaný znak pro oddělení komponent cesty v závislosti na hostitelském operačním systému.
`relative_path`	Vrátí relativní cestu komponentu `myname`.
`remove_filename`	Odebere název souboru.
`replace_extension`	Nahradí příponu .`myname`
`replace_filename`	Nahradí název souboru.
`root_directory`	Vrátí kořenovou složku adresáře .`myname`
`root_name`	Vrátí součást kořenového názvu .`myname`
`root_path`	Vrátí součást kořenové cesty .`myname`
`stem`	Vrátí komponentu `stem` .`myname`
`string`	Převede sekvenci uloženou v `mypath`souboru .
`swap`	`swap(mypath, right.mypath)`Spustí .
`u16string`	Převede sekvenci uloženou na `mypath` UTF-16 a vrátí ji uloženou v objektu typu `u16string`.
`u32string`	Převede sekvenci uloženou na `mypath` UTF-32 a vrátí ji uloženou v objektu typu `u32string`.
`u8string`	Převede sekvenci uloženou na `mypath` UTF-8 a vrátí ji uloženou v objektu typu `u8string`.
`value_type`	Typ popisuje prvky cesty upřednostňované hostitelským operačním systémem.
`wstring`	Převede sekvenci uloženou na `mypath` kódování upřednostňované hostitelským systémem pro `wchar_t` sekvenci a vrátí ji uloženou v objektu typu `wstring`.

Operátory

Operátor	Popis
`operator=`	Nahradí prvky cesty kopií jiné cesty.
`operator+=`	Různé `concat` výrazy.
`operator/=`	Různé `append` výrazy.
`operator string_type`	Vrací objekt `myname`.

Požadavky

Záhlaví: <filesystem>

Obor názvů: std::experimental::filesystem

`path::append`

Připojí zadanou sekvenci k mypathpřevedené a vložení podle preferred_separator potřeby.

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

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

Parametry

source
Zadaná sekvence.

first
Začátek zadané sekvence

last
Konec zadané sekvence.

`path::assign`

mypath Nahradí zadanou sekvencí převedenou podle potřeby.

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

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

Parametry

source
Zadaná sekvence.

first
Začátek zadané sekvence

last
Konec zadané sekvence.

`path::begin`

path::iterator Vrátí označení prvního prvku cesty v pathname, pokud je k dispozici.

iterator begin() const;

`path::c_str`

Vrátí ukazatel na první znak v argumentu mypath.

const value_type& *c_str() const noexcept;

`path::clear`

mypath.clear()Spustí .

void clear() noexcept;

`path::compare`

První funkce vrátí mypath.compare(pval.native()). Druhá funkce vrátí mypath.compare(str). Třetí funkce vrátí mypath.compare(ptr).

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

Parametry

pval
Cesta k porovnání

str
Řetězec, který chcete porovnat.

ptr
Ukazatel, který chcete porovnat.

`path::concat`

Připojí zadanou sekvenci k mypathpřevedené (ale ne vložení oddělovače) podle potřeby.

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

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

Parametry

source
Zadaná sekvence.

first
Začátek zadané sekvence

last
Konec zadané sekvence.

`path::const_iterator`

Synonymum pro iterator.

typedef iterator const_iterator;

`path::empty`

Vrací objekt mypath.empty().

bool empty() const noexcept;

`path::end`

Vrátí iterátor typu iteratorend-of-sequence .

iterator end() const;

`path::extension`

Vrátí příponu .filename()

path extension() const;

Poznámky

Vrátí příponu filename() X takového:

Pokud X == path(".") || X == path("..") nebo pokud X neobsahuje tečku, je přípona prázdná.

V opačném případě přípona začíná (a obsahuje) nejvíce vpravo tečka.

`path::filename`

Vrátí kořenovou složku mynameadresáře , konkrétně empty() path() : *--end(). Komponenta může být prázdná.

path filename() const;

`path::generic_string`

Vrátí všechny this->string<Elem, Traits, Alloc>(al) zpětné lomítko převedené na lomítko (v systému Windows).

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`

Vrátí všechny u16string() zpětné lomítko převedené na lomítko (v systému Windows).

u16string generic_u16string() const;

`path::generic_u32string`

Vrátí všechny u32string() zpětné lomítko převedené na lomítko (v systému Windows).

u32string generic_u32string() const;

`path::generic_u8string`

Vrátí všechny u8string() zpětné lomítko převedené na lomítko (v systému Windows).

string generic_u8string() const;

`path::generic_wstring`

Vrátí všechny wstring() zpětné lomítko převedené na lomítko (v systému Windows).

wstring generic_wstring() const;

`path::has_extension`

Vrací objekt !extension().empty().

bool has_extension() const;

`path::has_filename`

Vrací objekt !filename().empty().

bool has_filename() const;

`path::has_parent_path`

Vrací objekt !parent_path().empty().

bool has_parent_path() const;

`path::has_relative_path`

Vrací objekt !relative_path().empty().

bool has_relative_path() const;

`path::has_root_directory`

Vrací objekt !root_directory().empty().

bool has_root_directory() const;

`path::has_root_name`

Vrací objekt !root_name().empty().

bool has_root_name() const;

`path::has_root_path`

Vrací objekt !root_path().empty().

bool has_root_path() const;

`path::has_stem`

Vrací objekt !stem().empty().

bool has_stem() const;

`path::is_absolute`

Pro Windows funkce vrátí has_root_name() && has_root_directory(). Pro POSIX vrátí has_root_directory()funkce .

bool is_absolute() const;

`path::is_relative`

Vrací objekt !is_absolute().

bool is_relative() const;

`path::iterator`

Obousměrný konstantní iterátor, který určuje součásti mynamecesty .

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

Poznámky

Třída popisuje obousměrný konstantní iterátor, který určuje path komponenty myname v sekvenci:

kořenový název, pokud je k dispozici
kořenový adresář, pokud je k dispozici
zbývající prvky adresáře nadřazeného pathobjektu , pokud jsou přítomné, končící názvem souboru, pokud jsou k dispozici

Pro pval objekt typu path:

path::iterator X = pval.begin() určuje první path prvek v cestě, pokud je k dispozici.
X == pval.end() je true v případech, kdy X body těsně za koncem sekvence součástí.
*X vrátí řetězec, který odpovídá aktuální komponentě.
++X určuje další komponentu v sekvenci, pokud je k dispozici.
--X určuje předchozí součást v sekvenci, pokud je k dispozici.
Změna zneplatní myname všechny iterátory označující prvky v mynamesouboru .

`path::make_preferred`

Převede každý oddělovač podle potřeby na požadovaný preferred_separator .

path& make_preferred();

`path::native`

Získejte nativní řetězcovou reprezentaci cesty.

const string_type& native() const noexcept;

Poznámky

Cesta je k dispozici v přenosném obecném formátu (viz generic_string()) nebo nativním formátu cesty. Tato funkce vrátí nativní řetězec. V systému POSIX jsou obecný formát a nativní formát stejné.

V následujícím příkladu spuštěném ve Windows 11 je c:/t/temp/temp.txt obecný řetězec cesty a nativní řetězec je 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=`

Nahradí prvky cesty kopií jiné cesty.

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

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

Parametry

right
Zkopírovaná path do souboru path.

source
Zdroj path.

Poznámky

První člen operátor zkopíruje right.myname do myname. Druhý operátor členu se přesune right.myname na myname. Operátor třetího člena se chová stejně jako *this = path(source)operátor .

`path::operator+=`

Různé concat výrazy.

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

Parametry

right
Přidaná cesta.

str
Přidaný řetězec.

ptr
Přidaný ukazatel.

elem
value_type Přidaný nebo Elem.

source
Přidaný zdroj.

Poznámky

Členské funkce se chovají stejně jako následující odpovídající výrazy:

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

`path::operator/=`

Různé append výrazy.

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

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

Parametry

right
Přidaná cesta.

source
Přidaný zdroj.

Poznámky

Členské funkce se chovají stejně jako následující odpovídající výrazy:

append(right);
append(source);

`path::operator string_type`

Vrací objekt myname.

operator string_type() const;

`path::parent_path`

Vrátí nadřazenou komponentu mynamecesty .

path parent_path() const;

Poznámky

Vrátí nadřazenou cestu komponentu myname, konkrétně předponu myname po odebrání filename().native() a všechny bezprostředně předcházející oddělovače adresářů. (Stejně, pokud begin() != end()je to kombinování všech prvků v rozsahu [begin(), --end()) následným použitím operator/=.) Komponenta může být prázdná.

`path::path`

Vytváří různé path způsoby.

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

Parametry

right
Cesta, z níž má být konstruovaná cesta kopií.

source
Zdrojem, jehož zkonstruovanou cestou je kopie.

loc
Zadané národní prostředí.

first
Pozice prvního prvku, který chcete zkopírovat.

last
Pozice posledního prvku, který se má zkopírovat.

Poznámky

Konstruktory všechny konstrukce myname různými způsoby:

Pro path() to je myname().

Pro path(const path& right) je myname(right.myname)to .

Pro path(path&& right) to je myname(right.myname).

Pro template<class Source> path(const Source& source) to je myname(source).

Pro template<class Source> path(const Source& source, const locale& loc) to je myname(source), získání všech potřebných codecvt omezujících vlastnost od loc.

Pro template<class InIt> path(InIt first, InIt last) to je myname(first, last).

Pro template<class InIt> path(InIt first, InIt last, const locale& loc) to je myname(first, last), získání všech potřebných codecvt omezujících vlastnost od loc.

`path::preferred_separator`

Konstantní objekt dává upřednostňovaný znak pro oddělení komponent cesty v závislosti na hostitelském operačním systému.

#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

Poznámky

Je to stejně přípustné ve většině kontextů v systému Windows, aby se používalo L'/' na svém místě.

`path::relative_path`

Vrátí relativní cestu komponentu myname.

path relative_path() const;

Poznámky

Vrátí relativní cestu komponenta myname, konkrétně příponu myname po odebrání root_path().native() a všechny okamžitě následné redundantní oddělovače adresářů. Komponenta může být prázdná.

`path::remove_filename`

Odebere název souboru.

path& remove_filename();

`path::replace_extension`

Nahradí příponu .myname

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

Parametry

newext
Nové rozšíření.

Poznámky

Nejprve odebere příponu extension().native() z myname. Pak pokud !newext.empty() && newext[0] != dot (kde tečka je*path(".").c_str()), pak tečka je připojena k myname. Pak newext se připojí k myname.

`path::replace_filename`

Nahradí název souboru.

path& replace_filename(const path& pval);

Parametry

pval
Cesta k názvu souboru.

Poznámky

Členová funkce provede:

remove_filename();

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

`path::root_directory`

Vrátí kořenovou složku adresáře .myname

path root_directory() const;

Poznámky

Komponenta může být prázdná.

`path::root_name`

Vrátí součást kořenového názvu .myname

path root_name() const;

Poznámky

Komponenta může být prázdná.

`path::root_path`

Vrátí součást kořenové cesty .myname

path root_path() const;

Poznámky

Vrátí kořenovou cestu součásti myname, konkrétně / root_name()root_directory . Komponenta může být prázdná.

`path::stem`

Vrátí komponentu stem .myname

path stem() const;

Poznámky

Vrátí komponentu stem myname, konkrétně filename().native() se všemi koncovými extension().native() odebranými. Komponenta může být prázdná.

`path::string`

Převede sekvenci uloženou v mypathsouboru .

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;

Poznámky

První členová funkce (šablona) převede sekvenci uloženou mypath stejným způsobem jako:

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

Druhá členská funkce převede sekvenci uloženou do mypath kódování, které je upřednostněno hostitelským systémem pro char sekvenci, a vrátí ji uloženou v objektu typu string.

`path::string_type`

Typ je synonymem pro basic_string<value_type>.

typedef basic_string<value_type> string_type;

`path::swap`

swap(mypath, right.mypath)Spustí .

void swap(path& right) noexcept;

`path::u16string`

Převede sekvenci uloženou na mypath UTF-16 a vrátí ji uloženou v objektu typu u16string.

u16string u16string() const;

`path::u32string`

Převede sekvenci uloženou na mypath UTF-32 a vrátí ji uloženou v objektu typu u32string.

u32string u32string() const;

`path::u8string`

Převede sekvenci uloženou na mypath UTF-8 a vrátí ji uloženou v objektu typu u8string.

string u8string() const;

`path::value_type`

Typ popisuje path prvky, které jsou upřednostňovány hostitelským operačním systémem.

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

`path::wstring`

Převede sekvenci uloženou na mypath kódování upřednostňované hostitelským systémem pro wchar_t sekvenci a vrátí ji uloženou v objektu typu wstring.

wstring wstring() const;

Viz také

Referenční informace k souborům hlaviček

Sdílet prostřednictvím

path Třída

Syntaxe

Konstruktory

Typedefs

Členské funkce

Operátory

Požadavky

path::append

Parametry

path::assign

Parametry

path::begin

path::c_str

path::clear

path::compare

Parametry

path::concat

Parametry

path::const_iterator

path::empty

path::end

path::extension

Poznámky

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

Poznámky

path::make_preferred

path::native

Poznámky

path::operator=

Parametry

Poznámky

path::operator+=

Parametry

Poznámky

path::operator/=

Parametry

Poznámky

path::operator string_type

path::parent_path

Poznámky

path::path

Parametry

Poznámky

path::preferred_separator

Poznámky

path::relative_path

Poznámky

path::remove_filename

path::replace_extension

Parametry

Poznámky

path::replace_filename

Parametry

Poznámky

path::root_directory

Poznámky

path::root_name

Poznámky

path::root_path

Poznámky

path::stem

Poznámky

path::string

`path` Třída

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