<utility>, funkcje

as_const

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

Wartość zwracana

Zwraca wartość T.

declval

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

exchange

(C++14) Przypisuje nową wartość do obiektu i zwraca jego starą wartość.

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

Parametry

val
Obiekt, który otrzyma wartość new_val.

new_val
Obiekt, którego wartość jest kopiowana lub przenoszona do valobiektu .

Uwagi

W przypadku typów exchange złożonych unika kopiowania starej wartości, gdy konstruktor przenoszenia jest dostępny, unika kopiowania nowej wartości, jeśli jest to obiekt tymczasowy lub jest przenoszony, i akceptuje dowolny typ jako nową wartość przy użyciu dowolnego dostępnego operatora przypisania konwersji. Funkcja exchange różni się od std::swap tego, że argument po lewej stronie nie jest przenoszony ani kopiowany do prawego argumentu.

Przykład

W poniższym przykładzie pokazano, jak używać polecenia exchange. W świecie exchange rzeczywistym najbardziej przydatne są duże obiekty, które są kosztowne do skopiowania:

#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

Warunkowo rzutuje swój argument do odwołania rvalue, jeśli argument to rvalue lub odwołanie rvalue. Spowoduje to przywrócenie cechy rvalue argumentu do funkcji przekazywania do przodu, aby obsłużyć doskonałe przekazywanie do przodu.

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 przekazanej Argwartości może być inny niż typ .Arg Zwykle określony przez argument szablonu funkcji przekazywania do przodu.

Arg
Argument do rzutowania.

Wartość zwracana

Zwraca odwołanie do wartości rvalue, jeśli Arg przekazana wartość Arg była pierwotnie rvalue lub odwołaniem do wartości rvalue. W przeciwnym razie zwraca Arg wartość bez modyfikowania jego typu.

Uwagi

Aby wywołać forwardmetodę , należy określić jawny argument szablonu.

forward nie przekazuje argumentu. Zamiast tego, warunkowo rzutując argument na odwołanie rvalue, jeśli pierwotnie był to odwołanie rvalue lub rvalue, forward umożliwia kompilatorowi wykonywanie rozpoznawania przeciążeń z wiedzą o oryginalnym typie argumentu przekazanego. Pozorny typ argumentu funkcji przekazywania może być inny niż jego oryginalny typ — na przykład gdy wartość rvalue jest używana jako argument funkcji i jest powiązana z nazwą parametru; posiadanie nazwy sprawia, że jest to wartość lvalue, z niezależnie od wartości, która rzeczywiście istnieje jako rvalue — forward przywraca wartość rvalue argumentu.

Przywrócenie wartości rvalue oryginalnej wartości argumentu w celu wykonania rozpoznawania przeciążenia jest nazywane idealnym przekazywaniem. Doskonałe przekazywanie do przodu umożliwia funkcji szablonu zaakceptowanie argumentu któregokolwiek typu odwołania i przywrócenie jego cechy rvalue, gdy jest to niezbędne do poprawnego rozwiązania przeciążenia. Za pomocą doskonałego przekazywania do przodu można zachować semantykę przenoszenia dla rvalue i uniknąć konieczności zapewnienia przeciążeń dla funkcji, które różnią się tylko pod względem typu odwołania ich argumentów.

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

Pobiera element z obiektu według pozycji indeksu pair lub według 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
Indeks 0 wybranego elementu.

T1
Typ pierwszego elementu pary.

T2
Typ drugiego elementu pary.

pr
Para do wyboru.

Uwagi

Funkcje szablonu zwracają odwołanie do elementu argumentu pair .

W przypadku indeksowanych przeciążeń, jeśli wartość to 0, zwracane Index pr.first funkcje, a wartość Index to 1, funkcja zwraca wartość pr.second. Typ RI jest typem zwracanego elementu.

W przypadku przeciążeń, które nie mają parametru Index , element do zwrócenia jest wywoływany przez argument typu. Wywołanie spowoduje wygenerowanie get<T>(Tuple) błędu kompilatora, jeśli pr zawiera więcej lub mniej niż jeden element typu T.

Przykład

#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

Funkcja szablonu, której można użyć do konstruowania obiektów typu pair, gdzie typy składników są wybierane automatycznie na podstawie typów danych przekazywanych 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
Wartość, która inicjuje pierwszy element elementu pair.

Val2
Wartość, która inicjuje drugi element elementu pair.

Wartość zwracana

Skonstruowany obiekt pary: pairT<,U>(Val1, ). Val2

Uwagi

make_pair Konwertuje obiekt typu reference_wrapper Klasa na typy referencyjne i konwertuje rozkładające się tablice i funkcje na wskaźniki.

W zwróconym pair obiekcie T jest określany w następujący sposób:

• Jeśli typ danych wejściowych to reference_wrapper<X>, zwracany typ T T to X&.

• W przeciwnym razie zwracany typ T to decay<T>::type. Jeśli decay klasa nie jest obsługiwana, zwracany typ T jest taki sam jak typ Tdanych wejściowych .

Zwrócony typ U jest podobnie określany z typu Uwejściowego .

Jedną z zalet make_pair jest to, że typy przechowywanych obiektów są określane automatycznie przez kompilator i nie muszą być jawnie określone. Nie używaj jawnych argumentów szablonu, takich jak make_pair<int, int>(1, 2) w przypadku użycia make_pair , ponieważ jest on pełny i dodaje złożone problemy referencyjne rvalue, które mogą powodować niepowodzenie kompilacji. W tym przykładzie poprawna składnia będzie następująca: make_pair(1, 2)

Funkcja make_pair pomocnika umożliwia również przekazanie dwóch wartości do funkcji wymagającej pary jako parametru wejściowego.

Przykład

Aby zapoznać się z przykładem użycia funkcji make_pair pomocniczej do deklarowania i inicjowania pary, zobacz pair Struktura.

move

Bezwarunkowo rzutuje swój argument na odwołanie rvalue, a tym samym sygnalizuje, że może być przeniesione, jeśli jego typ umożliwia przenoszenie.

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

Parametry

Type
Typ wywołany typem argumentu przekazanego w Argelemencie , wraz z regułami zwijania odwołań.

Arg
Argument do rzutowania. Chociaż typ elementu Arg wydaje się być określony jako odwołanie do wartości rvalue, akceptuje również argumenty lvalue, move ponieważ odwołania lvalue mogą wiązać się z odwołaniami rvalue.

Wartość zwracana

Arg jako odwołanie rvalue, niezależnie od tego, czy jego typ jest typem referencyjnym.

Uwagi

Argument Type szablonu nie jest przeznaczony do jawnego określenia, ale należy go wywnioskować z typu wartości przekazanej w Argpliku . Typ Type elementu jest dodatkowo dostosowywany zgodnie z regułami zwijania odwołań.

move nie przenosi argumentu. Zamiast tego, przez bezwarunkowe rzutowanie argumentu — co może być lvalue — odwołaniem do wartości rvalue, umożliwia kompilatorowi późniejsze przeniesienie, a nie skopiowanie wartości przekazanej Arg , jeśli jego typ jest włączony przenoszenie. Jeśli jego typ nie jest włączony, zostanie skopiowany.

Jeśli przekazana Arg wartość jest wartością lvalue — oznacza to, że ma nazwę lub jej adres — jest ona unieważniona po przeniesieniu. Nie należy odwoływać się do wartości przekazanej Arg przez jej nazwę lub adres po jej przeniesieniu.

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

Wymienia elementy dwóch typów lub pair obiektów struktury .

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
Obiekt typu lub typu pair.

right
Obiekt typu lub typu pair.

Uwagi

Jedną z zalet swap jest to, że typy przechowywanych obiektów są określane automatycznie przez kompilator i nie muszą być jawnie określone. Nie używaj jawnych argumentów szablonu, takich jak swap<int, int>(1, 2) w przypadku użycia swap , ponieważ jest on pełny i dodaje złożone problemy referencyjne rvalue, które mogą powodować niepowodzenie kompilacji.

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

Uwagi

Konwertuje wartość na ciąg znaków, wypełniając zakres [first, last), gdzie [first, last) jest wymagany do prawidłowego zakresu.