Fungsi `<utility>`

Artikel
06/16/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;

Tampilkan Nilai

Menampilkan T.

`declval`

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

`exchange`

(C++14) Menetapkan nilai baru ke objek dan mengembalikan nilai lamanya.

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

Parameter

val
Objek yang akan menerima nilai new_val.

new_val
Objek yang nilainya disalin atau dipindahkan ke .val

Keterangan

Untuk jenis kompleks, exchange hindari menyalin nilai lama saat konstruktor pemindahan tersedia, menghindari penyalinan nilai baru jika merupakan objek sementara atau dipindahkan, dan menerima jenis apa pun sebagai nilai baru, menggunakan operator penugasan konversi yang tersedia. Fungsi pertukaran berbeda dari std::swap dalam argumen kiri tidak dipindahkan atau disalin ke argumen kanan.

Contoh

Contoh berikut menunjukkan cara menggunakan exchange. Di dunia nyata, exchange paling berguna dengan objek besar yang mahal untuk disalin:

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

Secara kondisional melemparkan argumennya ke referensi rvalue jika argumen adalah referensi rvalue atau rvalue. Ini memulihkan rvalue-ness argumen ke fungsi penerusan untuk mendukung penerusan yang sempurna.

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

Parameter

Type
Jenis nilai yang diteruskan dalam Arg, yang mungkin berbeda dari jenis Arg. Biasanya ditentukan oleh argumen templat dari fungsi penerusan.

Arg
Argumen untuk dilemparkan.

Tampilkan Nilai

Mengembalikan referensi rvalue ke Arg jika nilai yang diteruskan Arg awalnya adalah rvalue atau referensi ke rvalue; jika tidak, mengembalikan Arg tanpa memodifikasi jenisnya.

Keterangan

Anda harus menentukan argumen templat eksplisit untuk memanggil forward.

forward tidak meneruskan argumennya. Sebagai gantinya, dengan secara kondisional mentransmisikan argumennya ke referensi rvalue jika awalnya merupakan referensi rvalue atau rvalue, forward memungkinkan kompilator untuk melakukan resolusi kelebihan beban dengan pengetahuan tentang jenis asli argumen yang diteruskan. Jenis argumen yang jelas ke fungsi penerusan mungkin berbeda dari jenis aslinya—misalnya, ketika rvalue digunakan sebagai argumen ke fungsi dan terikat ke nama parameter; memiliki nama menjadikannya lvalue, dengan nilai apa pun yang sebenarnya ada sebagai rvalue— forward memulihkan rvalue-ness argumen.

Memulihkan rvalue-ness dari nilai asli argumen untuk melakukan resolusi kelebihan beban dikenal sebagai penerusan yang sempurna. Penerusan sempurna memungkinkan fungsi templat untuk menerima argumen jenis referensi dan untuk memulihkan rvalue-ness ketika diperlukan untuk resolusi kelebihan beban yang benar. Dengan menggunakan penerusan yang sempurna, Anda dapat mempertahankan semantik pemindahan untuk rvalue dan menghindari keharusan menyediakan kelebihan beban untuk fungsi yang hanya bervariasi menurut jenis referensi argumen mereka.

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`

Mendapatkan elemen dari pair objek menurut posisi indeks, atau berdasarkan jenis.

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

Parameter

Index
Indeks berbasis 0 dari elemen yang dipilih.

T1
Jenis elemen pasangan pertama.

T2
Jenis elemen pasangan kedua.

pr
Pasangan yang akan dipilih.

Keterangan

Templat memfungsikan masing-masing mengembalikan referensi ke elemen argumennya pair .

Untuk kelebihan beban yang diindeks, jika nilai Index adalah 0 fungsi yang dikembalikan pr.first dan jika nilainya Index adalah 1 fungsi mengembalikan pr.second. Jenisnya RI adalah jenis elemen yang dikembalikan.

Untuk kelebihan beban yang tidak memiliki parameter, elemen yang Index akan dikembalikan disimpulkan oleh argumen jenis. get<T>(Tuple) Panggilan akan menghasilkan kesalahan kompilator jika pr berisi lebih atau kurang dari satu elemen jenis T.

Contoh

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

Fungsi templat yang dapat Anda gunakan untuk membuat objek jenis pair, di mana jenis komponen secara otomatis dipilih berdasarkan jenis data yang diteruskan sebagai parameter.

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

Parameter

Val1
Nilai yang menginisialisasi elemen pertama dari pair.

Val2
Nilai yang menginisialisasi elemen kedua dari pair.

Tampilkan Nilai

Objek pasangan yang dibangun: pairT<,U>(Val1, ). Val2

Keterangan

make_pair mengonversi objek jenis reference_wrapper Kelas ke jenis referensi dan mengonversi array dan fungsi yang membusuk menjadi penunjuk.

Dalam objek yang dikembalikan pair , T ditentukan sebagai berikut:

Jika jenis T input adalah reference_wrapper<X>, jenis T yang dikembalikan adalah X&.
Jika tidak, jenis T yang dikembalikan adalah decay<T>::type. Jika decay Kelas tidak didukung, jenis T yang dikembalikan sama dengan jenis Tinput .

Jenis U yang dikembalikan juga ditentukan dari jenis Uinput .

Salah satu keuntungannya make_pair adalah bahwa jenis objek yang sedang disimpan ditentukan secara otomatis oleh pengkompilasi dan tidak harus ditentukan secara eksplisit. Jangan gunakan argumen templat eksplisit seperti make_pair<int, int>(1, 2) saat Anda menggunakan make_pair karena verbose dan menambahkan masalah referensi rvalue kompleks yang dapat menyebabkan kegagalan kompilasi. Untuk contoh ini, sintaks yang benar adalah make_pair(1, 2)

Fungsi pembantu make_pair juga memungkinkan untuk meneruskan dua nilai ke fungsi yang memerlukan pasangan sebagai parameter input.

Contoh

Untuk contoh tentang cara menggunakan fungsi make_pair pembantu untuk mendeklarasikan dan menginisialisasi pasangan, lihat pair Struktur.

`move`

Secara tidak bersyarat melemparkan argumennya ke referensi rvalue, dan dengan demikian menandakan bahwa argumen tersebut dapat dipindahkan jika jenisnya diaktifkan.

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

Parameter

Type
Jenis yang disimpulkan dari jenis argumen yang diteruskan di Arg, bersama dengan referensi menciutkan aturan.

Arg
Argumen untuk dilemparkan. Meskipun jenis Arg tampaknya ditentukan sebagai referensi rvalue, move juga menerima argumen lvalue karena referensi lvalue dapat mengikat referensi rvalue.

Tampilkan Nilai

Arg sebagai referensi rvalue, apakah jenisnya adalah jenis referensi atau tidak.

Keterangan

Argumen Type templat tidak dimaksudkan untuk ditentukan secara eksplisit, tetapi akan disimpulkan dari jenis nilai yang diteruskan dalam Arg. Jenis Type disesuaikan lebih lanjut sesuai dengan aturan penciutkan referensi.

move tidak memindahkan argumennya. Sebaliknya, dengan secara tidak bersyarat mentransmisikan argumennya—yang mungkin merupakan lvalue—ke referensi rvalue, itu memungkinkan pengkompilasi untuk selanjutnya memindahkan, daripada menyalin, nilai yang diteruskan Arg jika jenisnya diaktifkan. Jika jenisnya tidak diaktifkan pindah, jenis tersebut akan disalin sebagai gantinya.

Jika nilai yang diteruskan Arg adalah lvalue—artinya, nilai tersebut memiliki nama atau alamatnya dapat diambil—nilai tersebut tidak valid saat pemindahan terjadi. Jangan merujuk ke nilai yang diteruskan Arg oleh nama atau alamatnya setelah dipindahkan.

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

Menukar elemen dari dua jenis atau pair Objek struktur .

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

Parameter

left
Objek jenis atau jenis pair.

right
Objek jenis atau jenis pair.

Keterangan

Salah satu keuntungannya swap adalah bahwa jenis objek yang sedang disimpan ditentukan secara otomatis oleh pengkompilasi dan tidak harus ditentukan secara eksplisit. Jangan gunakan argumen templat eksplisit seperti swap<int, int>(1, 2) saat Anda menggunakan swap karena verbose dan menambahkan masalah referensi rvalue kompleks yang dapat menyebabkan kegagalan kompilasi.

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

Keterangan

Mengonversi nilai menjadi string karakter dengan mengisi rentang [first, last), di mana [first, last) diperlukan untuk menjadi rentang yang valid.

Bagikan melalui

Fungsi `<utility>`

`as_const`

Tampilkan Nilai

`declval`

`exchange`

Parameter

Keterangan

Contoh

`forward`

Parameter

Tampilkan Nilai

Keterangan

from_chars

`get`

Parameter

Keterangan

Contoh

`index_sequence`

`index_sequence_for`

`make_index_sequence`

`make_integer_sequence`

`make_pair`

Parameter

Tampilkan Nilai

Keterangan

Contoh

`move`

Parameter

Tampilkan Nilai

Keterangan

`move_if_noexcept`

`swap`

Parameter

Keterangan

`to_chars`

Keterangan

Saran dan Komentar

Sumber Daya Tambahan:

Bagikan melalui

Fungsi <utility>

as_const

Tampilkan Nilai

declval

exchange

Parameter

Keterangan

Contoh

forward

Parameter

Tampilkan Nilai

Keterangan

from_chars

get

Parameter

Keterangan

Contoh

index_sequence

index_sequence_for

make_index_sequence

make_integer_sequence

make_pair

Parameter

Tampilkan Nilai

Keterangan

Contoh

move

Parameter

Tampilkan Nilai

Keterangan

move_if_noexcept

swap

Parameter

Keterangan

to_chars

Keterangan

Saran dan Komentar

Sumber Daya Tambahan:

Fungsi `<utility>`

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