`<utility>` – funkce

Článek
10/12/2023

`as_const`

template <class T> constexpr add_const_t<T>& as_const(T& t) noexcept;
template <class T> void as_const(const T&&) = delete;

Vrácená hodnota

Vrací objekt T.

`declval`

template <class T> add_rvalue_reference_t<T> declval() noexcept;  // as unevaluated operand

`exchange`

(C++14) Přiřadí objektu novou hodnotu a vrátí její starou hodnotu.

template <class T, class Other = T>
    T exchange(T& val, Other&& new_val)

Parametry

val
Objekt, který obdrží hodnotu new_val.

new_val
Objekt, jehož hodnota je zkopírována nebo přesunuta do val.

Poznámky

U složitých typů exchange se vyhnete kopírování staré hodnoty, pokud je k dispozici konstruktor přesunutí, zabrání kopírování nové hodnoty, pokud se jedná o dočasný objekt nebo je přesunut, a přijímá jakýkoli typ jako novou hodnotu pomocí libovolného dostupného operátoru převodu přiřazení. Funkce výměny se liší od std::swap toho, že se levý argument nepřesune nebo zkopíruje do pravého argumentu.

Příklad

Následující příklad ukazuje, jak používat exchange. Ve skutečném světě exchange je nejužitečnější u velkých objektů, které jsou nákladné kopírování:

#include <utility>
#include <iostream>

using namespace std;

struct C
{
   int i;
   //...
};

int main()
{
   // Use brace initialization
   C c1{ 1 };
   C c2{ 2 };
   C result = exchange(c1, c2);
   cout << "The old value of c1 is: " << result.i << endl;
   cout << "The new value of c1 after exchange is: " << c1.i << endl;

   return 0;
}

The old value of c1 is: 1
The new value of c1 after exchange is: 2

`forward`

Podmíněně přetypuje svůj argument na odkaz rvalue, pokud je argument hodnota rvalue nebo odkaz rvalue. Tím se období hodnota rvalue argumentu na funkci předání za účelem maximální podpory předávání.

template <class Type>    // accepts lvalues
    constexpr Type&& forward(typename remove_reference<Type>::type& Arg) noexcept

template <class Type>    // accepts everything else
    constexpr Type&& forward(typename remove_reference<Type>::type&& Arg) noexcept

Parametry

Type
Typ předané Arghodnoty , která se může lišit od typu Arg. Obvykle určeno argumentem šablony funkce předávání.

Arg
Argument, který chcete přetypovat.

Vrácená hodnota

Vrátí odkaz rvalue na Arg to, zda byla hodnota předaná Arg původně hodnotou rvalue nebo odkazem na hodnotu rvalue. V opačném případě vrátí hodnotu Arg beze změny jejího typu.

Poznámky

Je nutné zadat explicitní argument šablony pro volání forward.

forward nepředá svůj argument. Místo toho podmíněným přetypováním argumentu na odkaz rvalue, pokud byl původně odkazem rvalue nebo rvalue, forward umožňuje kompilátoru provádět řešení přetížení s vědomím původního typu přeposlaného argumentu. Zdánlivý typ argumentu pro funkci předávání se může lišit od původního typu – například když se hodnota rvalue použije jako argument funkce a je svázaná s názvem parametru; když má název hodnotu lvalue, s libovolnou hodnotou, která skutečně existuje jako hodnota rvalue, forward obnoví hodnotu rvalue- ness argumentu.

Obnovení rvalue-ness původní hodnoty argumentu k vyřešení přetížení se označuje jako dokonalé předávání. Dokonalé předávání umožňuje funkci šablony přijmout argument některého typu odkazu a obnovit jeho vlastnost rvalue, když je nezbytná pro správné řešení přetížení. Pomocí dokonalého předávání můžete zachovat sémantiku přesunu pro hodnoty rvalue. Nebude tak nutné poskytovat přetížení pro funkce, které se liší pouze typem odkazu svých argumentů.

from_chars

from_chars_result from_chars(const char* first, const char* last, see below& value, int base = 10);

from_chars_result from_chars(const char* first, const char* last, float& value, chars_format fmt = chars_format::general);

from_chars_result from_chars(const char* first, const char* last, double& value, chars_format fmt = chars_format::general);

from_chars_result from_chars(const char* first, const char* last, long double& value, chars_format fmt = chars_format::general);

`get`

Získá prvek z objektu pair podle pozice indexu nebo podle typu.

// get reference to element at Index in pair Pr
template <size_t Index, class T1, class T2>
    constexpr tuple_element_t<Index, pair<T1, T2>>&
    get(pair<T1, T2>& Pr) noexcept;

// get reference to element T1 in pair Pr
template <class T1, class T2>
    constexpr T1& get(pair<T1, T2>& Pr) noexcept;

// get reference to element T2 in pair Pr
template <class T2, class T1>
    constexpr T2& get(pair<T1, T2>& Pr) noexcept;

// get const reference to element at Index in pair Pr
template <size_t Index, class T1, class T2>
    constexpr const tuple_element_t<Index, pair<T1, T2>>&
    get(const pair<T1, T2>& Pr) noexcept;

// get const reference to element T1 in pair Pr
template <class T1, class T2>
    constexpr const T1& get(const pair<T1, T2>& Pr) noexcept;

// get const reference to element T2 in pair Pr
template <class T2, class T1>
    constexpr const T2& get(const pair<T1, T2>& Pr) noexcept;

// get rvalue reference to element at Index in pair Pr
template <size_t Index, class T1, class T2>
    constexpr tuple_element_t<Index, pair<T1, T2>>&&
    get(pair<T1, T2>&& Pr) noexcept;

// get rvalue reference to element T1 in pair Pr
template <class T1, class T2>
    constexpr T1&& get(pair<T1, T2>&& Pr) noexcept;

// get rvalue reference to element T2 in pair Pr
template <class T2, class T1>
    constexpr T2&& get(pair<T1, T2>&& Pr) noexcept;

Parametry

Index
Index založený na 0 zvoleném prvku.

T1
Typ prvního párového prvku.

T2
Typ druhého párového prvku.

pr
Dvojice, ze které chcete vybrat.

Poznámky

Funkce šablony vrátí odkaz na prvek jeho pair argumentu.

U indexovaných přetížení, pokud je hodnota Index 0, vrátí pr.first funkce a pokud je hodnota Index 1, vrátí pr.secondfunkce . RI Typ je typ vráceného prvku.

U přetížení, které nemají Index parametr, je prvek, který se má vrátit, odvozen argumentem typu. Volání get<T>(Tuple) vytvoří chybu kompilátoru, pokud pr obsahuje více nebo méně než jeden prvek typu T.

Příklad

#include <utility>
#include <iostream>
using namespace std;
int main()
{
    typedef pair<int, double> MyPair;

    MyPair c0(9, 3.14);

    // get elements by index
    cout << " " << get<0>(c0);
    cout << " " << get<1>(c0) << endl;

    // get elements by type (C++14)
    MyPair c1(1, 0.27);
    cout << " " << get<int>(c1);
    cout << " " << get<double>(c1) << endl;
}

9 3.14
1 0.27

`index_sequence`

template<size_t... I>
    using index_sequence = integer_sequence<size_t, I...>;

`index_sequence_for`

template<class... T>
    using index_sequence_for = make_index_sequence<sizeof...(T)>;

`make_index_sequence`

template<size_t N>
    using make_index_sequence = make_integer_sequence<size_t, N>;

`make_integer_sequence`

template<class T, T N>
    using make_integer_sequence = integer_sequence<T, see below >;

`make_pair`

Funkce šablony, kterou můžete použít k vytvoření objektů typu pair, kde jsou typy komponent automaticky vybrány na základě datových typů, které jsou předány jako parametry.

template <class T, class U>
    pair<T, U> make_pair(T& Val1, U& Val2);

template <class T, class U>
    pair<T, U> make_pair(T& Val1, U&& Val2);

template <class T, class U>
    pair<T, U> make_pair(T&& Val1, U& Val2);

template <class T, class U>
    pair<T, U> make_pair(T&& Val1, U&& Val2);

Parametry

Val1
Hodnota, která inicializuje první prvek .pair

Val2
Hodnota, která inicializuje druhý prvek .pair

Vrácená hodnota

Objekt páru vytvořený: pairT<,U>(Val1, ). Val2

Poznámky

make_pair převede objekt typu reference_wrapper Třída na odkazové typy a převede rozkládající se pole a funkce na ukazatele.

Ve vráceném pair objektu T je určen takto:

Pokud je reference_wrapper<X>vstupní typ T , vrácený typ T je X&.
V opačném případě je decay<T>::typevrácený typ T . Pokud decay třída není podporována, vrácený typ T je stejný jako vstupní typ T.

Vrácený typ U je podobně určen ze vstupního typu U.

Jednou z make_pair výhod je, že typy objektů, které jsou uloženy, jsou určeny automaticky kompilátorem a nemusí být explicitně zadány. Nepoužívejte explicitní argumenty šablony, jako make_pair<int, int>(1, 2) je při použití make_pair , protože se jedná o podrobné a přidává komplexní problémy s odkazem na rvalue, které by mohly způsobit selhání kompilace. V tomto příkladu by správná syntaxe byla make_pair(1, 2)

Pomocná make_pair funkce také umožňuje předat funkci dvě hodnoty, které vyžadují pár jako vstupní parametr.

Příklad

Příklad použití pomocné funkce make_pair k deklaraci a inicializaci páru naleznete v tématu pair Struktura.

`move`

Bezpodmínečně přetypuje svůj argument na odkaz hodnoty rvalue a značí, že ji lze přesunout, pokud je pro její typ přesunutí povoleno.

template <class Type>
    constexpr typename remove_reference<Type>::type&& move(Type&& Arg) noexcept;

Parametry

Type
Typ vyvolaný z typu předaného Argargumentu spolu s referenčními sbalovacími pravidly.

Arg
Argument, který chcete přetypovat. Ačkoli se zdá, že typ Arg je zadán jako odkaz rvalue, přijímá také argumenty lvalue, move protože odkazy lvalue mohou svázat s odkazy rvalue.

Vrácená hodnota

Arg jako odkaz rvalue, zda jeho typ je typ odkazu.

Poznámky

Argument šablony Type není určen explicitně, ale má být odvozen z typu předané Arghodnoty . Typ Type je dále upraven podle pravidel sbalení odkazů.

move nepřesune svůj argument. Místo toho bezpodmínečně přetypováním argumentu ( což může být lvalue) na odkaz rvalue, umožňuje kompilátoru následně přesunout místo kopírování hodnotu předanou Arg , pokud je její typ povolen pro přesunutí. Pokud jeho typ není povolený, zkopíruje se místo toho.

Pokud je předaná Arg hodnota lvalue – to znamená, že má název nebo jeho adresu, je možné ji vzít – při přesunu se zneplatní. Po přesunutí neodkazujte na hodnotu předanou Arg jejím názvem nebo adresou.

`move_if_noexcept`

template <class T> constexpr conditional_t< !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&> move_if_noexcept(T& x) noexcept;

`swap`

Vymění prvky dvou typů nebo pair objektů Structure .

template <class T>
    void swap(T& left, T& right) noexcept(see below );
template <class T, size_t N>
    void swap(T (&left)[N], T (&right)[N]) noexcept(is_nothrow_swappable_v<T>);
template <class T, class U>
    void swap(pair<T, U>& left, pair<T, U>& right);

Parametry

left
Objekt typu nebo typu pair.

right
Objekt typu nebo typu pair.

Poznámky

Jednou z swap výhod je, že typy objektů, které jsou uloženy, jsou určeny automaticky kompilátorem a nemusí být explicitně zadány. Nepoužívejte explicitní argumenty šablony, jako swap<int, int>(1, 2) je při použití swap , protože se jedná o podrobné a přidává komplexní problémy s odkazem na rvalue, které by mohly způsobit selhání kompilace.

`to_chars`

to_chars_result to_chars(char* first, char* last, see below value, int base = 10);
to_chars_result to_chars(char* first, char* last, float value);
to_chars_result to_chars(char* first, char* last, double value);
to_chars_result to_chars(char* first, char* last, long double value);
to_chars_result to_chars(char* first, char* last, float value, chars_format fmt);
to_chars_result to_chars(char* first, char* last, double value, chars_format fmt);
to_chars_result to_chars(char* first, char* last, long double value, chars_format fmt);
to_chars_result to_chars(char* first, char* last, float value, chars_format fmt, int precision);
to_chars_result to_chars(char* first, char* last, double value, chars_format fmt, int precision);
to_chars_result to_chars(char* first, char* last, long double value, chars_format fmt, int precision);

Poznámky

Převede hodnotu na řetězec znaků vyplněním oblasti [first, last), kde [first, last) je nutné, aby byla platná oblast.

Sdílet prostřednictvím

`<utility>` – funkce

`as_const`

Vrácená hodnota

`declval`

`exchange`

Parametry

Poznámky

Příklad

`forward`

Parametry

Vrácená hodnota

Poznámky

from_chars

`get`

Parametry

Poznámky

Příklad

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

Parametry

Vrácená hodnota

Poznámky

Příklad

`move`

Parametry

Vrácená hodnota

Poznámky

`move_if_noexcept`

`swap`

Parametry

Poznámky

`to_chars`

Poznámky

Váš názor

Váš názor

Další materiály

Sdílet prostřednictvím

<utility> – funkce

as_const

Vrácená hodnota

declval

exchange

Parametry

Poznámky

Příklad

forward

Parametry

Vrácená hodnota

Poznámky

from_chars

get

Parametry

Poznámky

Příklad

index_sequence

index_sequence_for

make_index_sequence

make_integer_sequence

make_pair

Parametry

Vrácená hodnota

Poznámky

Příklad

move

Parametry

Vrácená hodnota

Poznámky

move_if_noexcept

swap

Parametry

Poznámky

to_chars

Poznámky

Váš názor

Váš názor

Další materiály

`<utility>` – funkce

`as_const`

`declval`

`exchange`

`forward`

`get`

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

`move`

`move_if_noexcept`

`swap`

`to_chars`