`<utility>` işlevleri

`as_const`

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

Dönüş Değeri

T döndürür.

`declval`

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

`exchange`

(C++14) Bir nesneye yeni bir değer atar ve eski değerini döndürür.

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

Parametreler

val
değerini new_valalacak nesne.

new_val
Değeri kopyalanan veya içine valtaşınan nesne.

Açıklamalar

Karmaşık türler için, exchange bir taşıma oluşturucu kullanılabilir olduğunda eski değerin kopyalanmasını önler, geçici bir nesneyse veya taşınırsa yeni değerin kopyalanmasını önler ve kullanılabilir dönüştürme atama işlecini kullanarak herhangi bir türü yeni değer olarak kabul eder. Exchange işlevi, sol bağımsız değişkenin sağ bağımsız değişkene taşınmadığından veya kopyalandığından farklıdır std::swap .

Örnek

Aşağıdaki örnekte nasıl kullanılacağı exchangegösterilmektedir. Gerçek dünyada, exchange kopyalaması pahalı olan büyük nesnelerde en kullanışlıdır:

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

Bağımsız değişken bir rvalue'da veya rvalue başvurusundaysa, bağımsız değişkenini bir rvalue başvurusuna koşullu olarak yayınlar. Bu, bir bağımsız değişkenin rvalue olma durumunu mükemmel iletim desteği sunarak iletim işlevine geri yükler.

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

Parametreler

Type
içinde geçirilen Argdeğerin türü, türünden Argfarklı olabilir. Genellikle iletme işlevinin bir şablon bağımsız değişkeni tarafından belirlenir.

Arg
Yayınlama için bağımsız değişkeni.

Dönüş Değeri

geçirilen Arg değerin başlangıçta bir rvalue veya rvalue başvurusu olup olmadığını belirten bir rvalue başvurusu Arg döndürür; aksi takdirde, türünü değiştirmeden döndürürArg.

Açıklamalar

çağrısı forwardyapmak için açık bir şablon bağımsız değişkeni belirtmeniz gerekir.

forward bağımsız değişkenini iletmez. Bunun yerine, bağımsız değişkenini başlangıçta bir rvalue veya rvalue başvurusuysa bir rvalue başvurusuna koşullu olarak atayarak, forward derleyicinin iletilen bağımsız değişkenin özgün türü hakkında bilgiyle aşırı yükleme çözümlemesi gerçekleştirmesini sağlar. İletme işlevine bağımsız değişkenin görünen türü özgün türünden farklı olabilir; örneğin, bir rvalue işlevin bağımsız değişkeni olarak kullanıldığında ve parametre adına bağlı olduğunda; bir ada sahip olmak onu bir lvalue yapar ve gerçekte rvalue olarak var olan değer, forward bağımsız değişkenin rvalue-ness değerini geri yükler.

Aşırı yükleme çözümlemesi yapmak için bağımsız değişkenin özgün değerinin rvalue-ness değerini geri yüklemek, mükemmel iletme olarak bilinir. Kusursuz iletme bir şablon işlevinin her iki başvuru türünün bağımsız değişkenini kabul etmesini ve aşırı yük çözümlemeleri yapılması gerektiğinde rvalue durumunu geri yüklemesini sağlar. Kusursuz iletme kullanarak, rvalues için taşıma semantiğini koruyabilir ve bağımsız değişkenlerinin yalnızca başvuru türüne göre çeşitlenen işlevler için aşırı yük sağlanmasını önleyebilirsiniz.

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`

Bir nesneden dizin konumuna veya türe göre öğe pair alır.

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

Parametreler

Index
Seçilen öğenin 0 tabanlı dizini.

T1
İlk çift öğesinin türü.

T2
İkinci çift öğesinin türü.

pr
Seçecek çift.

Açıklamalar

Şablon işlevlerinin her biri bağımsız değişkeninin pair bir öğesine başvuru döndürür.

Dizine alınan aşırı yüklemeler için değeri Index 0 ise işlevleri döndürür pr.first ve değeri Index 1 ise işlevleri döndürür pr.second. türü RI , döndürülen öğenin türüdür.

Parametresi olmayan Index aşırı yüklemeler için döndürülecek öğe tür bağımsız değişkeni tarafından oluşturulur. Çağrısıget<T>(Tuple), türünde Tbirden fazla veya daha az öğe içeriyorsa bir derleyici hatası pr oluşturur.

Örnek

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

parametre olarak geçirilen veri türlerine göre bileşen türlerinin pairotomatik olarak seçildiği türündeki nesneleri oluşturmak için kullanabileceğiniz bir şablon işlevi.

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

Parametreler

Val1
öğesinin ilk öğesini pairbaşlatan değer.

Val2
öğesinin ikinci öğesini pairbaşlatan değer.

Dönüş Değeri

Oluşturulan çift nesnesi: pairT<,U>(Val1, ). Val2

Açıklamalar

make_pairSınıf türünde reference_wrapper bir nesneyi başvuru türlerine dönüştürür ve bozulan dizileri ve işlevleri işaretçilere dönüştürür.

Döndürülen pair nesnede aşağıdaki T gibi belirlenir:

Giriş türü T ise reference_wrapper<X>, döndürülen tür T olur X&.
Aksi takdirde, döndürülen tür T şeklindedir decay<T>::type. Sınıf desteklenmiyorsadecay, döndürülen tür T giriş türüyle Taynıdır.

Döndürülen tür U benzer şekilde giriş türünden Ubelirlenir.

Bunun bir avantajı make_pair , depolanmakta olan nesne türlerinin derleyici tarafından otomatik olarak belirlenmesi ve açıkça belirtilmesi gerekmeyecek olmasıdır. Ayrıntılı olduğu ve derleme hatasına neden olabilecek karmaşık rvalue başvuru sorunları eklediği için kullandığınız make_pair durumlar gibi make_pair<int, int>(1, 2) açık şablon bağımsız değişkenlerini kullanmayın. Bu örnekte doğru söz dizimi make_pair(1, 2)

make_pair Yardımcı işlevi, giriş parametresi olarak çift gerektiren bir işleve iki değer geçirmeyi de mümkün kılar.

Örnek

Yardımcı işlevini make_pair kullanarak bir çifti bildirme ve başlatma hakkında bir örnek için bkz pair . Yapı.

`move`

Kendi bağımsız değişkenini koşulsuz olarak bir rvalue başvurusuna yayınlar ve böylece kendi türünün taşınması etkinse, taşınabileceğini belirtir.

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

Parametreler

Type
içinde geçirilen Argbağımsız değişkenin türünden oluşturulan bir tür, başvuru daraltma kurallarıyla birlikte.

Arg
Yayınlama için bağımsız değişkeni. türü Arg rvalue başvurusu olarak belirtilmiş gibi görünse de, move lvalue başvuruları rvalue başvurularına bağlanabildiğinden lvalue bağımsız değişkenlerini de kabul eder.

Dönüş Değeri

Arg türü bir başvuru türü olup olmadığıyla ilgili bir rvalue başvurusu olarak.

Açıklamalar

Şablon bağımsız değişkeninin Type açıkça belirtilmesi amaçlanmamıştır, ancak içinde geçirilen değerin türünden çıkarılacaktır Arg. Türü Type , başvuru daraltma kurallarına göre daha da ayarlanır.

move bağımsız değişkenini taşımaz. Bunun yerine, bağımsız değişkenini (lvalue olabilir) koşulsuz olarak bir rvalue başvurusuna dönüştürerek, türü move-enabled olduğunda geçirilen Arg değeri kopyalamak yerine derleyicinin daha sonra taşımasını sağlar. Türü taşıma etkin değilse, kopyalanır.

geçirilen Arg değer bir lvalue ise (başka bir deyişle, bir ada sahipse veya adresi alınabilirse), taşıma işlemi gerçekleştiğinde geçersiz kılınmış olur. Taşındıktan sonra adı veya adresiyle geçirilen Arg değere başvurmayın.

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

İki tür veya pair Yapı nesnelerinin öğelerini değiştirir.

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

Parametreler

left
türünde veya türünde pairbir nesne.

right
türünde veya türünde pairbir nesne.

Açıklamalar

Bunun bir avantajı swap , depolanmakta olan nesne türlerinin derleyici tarafından otomatik olarak belirlenmesi ve açıkça belirtilmesi gerekmeyecek olmasıdır. Ayrıntılı olduğu ve derleme hatasına neden olabilecek karmaşık rvalue başvuru sorunları eklediği için kullandığınız swap durumlar gibi swap<int, int>(1, 2) açık şablon bağımsız değişkenlerini kullanmayın.

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

Açıklamalar

Geçerli bir aralık olması gereken aralığını [first, last)[first, last) doldurarak değeri bir karakter dizesine dönüştürür.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

<utility> işlevleri

as_const

Dönüş Değeri

declval

exchange

Parametreler

Açıklamalar

Örnek

forward

Parametreler

Dönüş Değeri

Açıklamalar

from_chars

get

Parametreler

Açıklamalar

Örnek

index_sequence

index_sequence_for

make_index_sequence

make_integer_sequence

make_pair

Parametreler

Dönüş Değeri

Açıklamalar

Örnek

move

Parametreler

Dönüş Değeri

Açıklamalar

move_if_noexcept

swap

Parametreler

Açıklamalar

to_chars

Açıklamalar

Geri Bildirim

Ek kaynaklar

`<utility>` işlevleri

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