« exchange, szablon funkcji, C++ »
exchange - Szablon funkcji zamieniający wartość danej zmiennej, zwracający poprzednią jej wartość. (szablon funkcji)
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!
Hasło nie zostało zweryfikowane
Niniejsze hasło zostało opracowane, jednak nie zostało ono zweryfikowane przez administrację serwisu. Jeżeli znalazłeś błędy merytoryczne w niniejszym dokumencie, prosimy o ich zgłoszenie na forum w dziale Znalezione błędy.
Opracował: baziorek
« Standard C++14 »

exchange

[szablon funkcji] Szablon funkcji zamieniający wartość danej zmiennej, zwracający poprzednią jej wartość.

Składnia

C/C++
#include <utility>

template < class T, class U = T >
T exchange( T & obj, U && new_value );

/// wraz z nadejściem C++20 zostanie zastąpiona na:
template < class T, class U = T >
constexpr T exchange( T & obj, U && new_value );

Parametry szablonu

ParametrOpis
Tjest typem zmiennej, której wartość podmieniamy, musi istnieć dla niego semantyka przenoszenia lub kopiowania
Ujest typem, z którego możliwe jest przenoszenie na typ T

Argumenty

ArgumentOpis
objzmienna, której wartość podmieniamy przez new_value, oraz zwracamy jej wartość przed zmianą
new_valuewartość, którą przenosimy na zmienną obj

Zwracana wartość

Wartość pierwszego argumentu funkcji przed zamianą.

Opis szczegółowy

Jest to szablon funkcji, który zastępuje wartość danej zmiennej typu T (podanej jako pierwszy argument) wartością drugiej zmiennej typu U (podanej jako drugi argument). Funkcja zwraca kopię wartości zmiennej typu T przed dokonaniem podmiany. Wartość drugiego argumentu typu U zostaje przeniesiona na pierwszy argument.

Dodatkowe informacje

Bardzo wygodna przy implementacji semantyki przenoszenia.

Rzucane wyjątki

Jeśli konstruktor przenoszący typu T może wyrzucić wyjątek, wtenczas konkretyzacja szablonu funkcji dla typu T może wyrzucić wyjątek.

Wymagania

Posiadanie implementacji szablonu funkcji, lub posiadanie kompilatora zgodnego z C++14.

Implementacja

C/C++
template < class T, class U = T >
T exchange( T & obj, U && new_value )
{
    T old_value = std::move( obj );
    obj = std::forward < U >( new_value );
    return old_value;
}
Źródło implementacji

Przykład

C/C++
#include <iostream>
#include <vector>
#include <iterator> // ostream_iterator
#include <utility>  // cbegin(), cend()

struct Ptr
{
    int * ptr = nullptr;
   
    Ptr() = default;
    Ptr( Ptr && rhs )
        : ptr( std::exchange( rhs.ptr, nullptr ) )
    { }
   
    Ptr & operator =( Ptr && rhs )
    {
        ptr = std::exchange( rhs.ptr, nullptr );
        return * this;
    }
};

void f()
{
    std::cout << __FUNCTION__ << "()\n";
}

int main()
{
    int a = 4, b = 5;
   
    Ptr ptrA;
    ptrA.ptr = & a;
    Ptr ptrB = std::move( ptrA );
   
    std::cout << "PtrA.ptr = " << ptrA.ptr << '\n';
    std::cout << "*PtrB.ptr = " << * ptrB.ptr << '\n';
   
    std::vector < int > v = { 1, 3, 5, 7, 9 };
   
    std::exchange( v, { 2, 4, 6, 8 } );
    std::copy( std::cbegin( v ), std::cend( v ), std::ostream_iterator < int >( std::cout, ", " ) );
    std::cout << '\n';
   
    void( * f_ptr )();
   
    std::exchange( f_ptr, f );
    f_ptr();
}
Standardowe wyjście programu:
g++ --std=c++14 tmp.cc && ./a.out
PtrA.ptr = 0
*PtrB.ptr = 4
2, 4, 6, 8,
f()

Zagadnienia powiązane

swapZamienia wartości dwóch obiektów. (szablon funkcji)