exchange

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

Składnia

#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

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

Argumenty

Argument	Opis
obj	zmienna, której wartość podmieniamy przez new_value, oraz zwracamy jej wartość przed zmianą
new_value	wartość, 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

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

#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

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

Linki zewnętrzne

http://en.cppreference.com/w/cpp/utility/exchange

Wszystkie teksty są chronione prawami autorskimi. Kopiowanie lub rozpowszechnianie treści poza niniejszym serwisem jest zabronione.

Powyższe ograniczenie nie dotyczy autora opracowania, któremu przysługuje prawo do rozpowszechniania własnego tekstu wedle własnego uznania.