fbpx

C++: Generic Swap

Bjarne-stroustrup
 

The task is to write a generic swap function or operator which exchanges the values of two variables (or, more generally, any two storage places that can be assigned), regardless of their types. If your solution language is statically typed please describe the way your language provides genericity.

If variables are typed in the given language, it is permissible that the two variables be constrained to having a mutually compatible type, such that each is permitted to hold the value previously stored in the other without a type violation. That is to say, solutions do not have to be capable of exchanging, say, a string and integer value, if the underlying storage locations are not attributed with types that permit such an exchange.

Generic swap is a task which brings together a few separate issues in programming language semantics.

Dynamically typed languages deal with values in a generic way quite readily, but do not necessarily make it easy to write a function to destructively swap two variables, because this requires indirection upon storage places or upon the syntax designating storage places.

Functional languages, whether static or dynamic, do not necessarily allow a destructive operation such as swapping two variables regardless of their generic capabilities.

Some static languages have difficulties with generic programming due to a lack of support for (Parametric Polymorphism).

Generic programming in C++ is provided through templates. Templates in C++ are quite powerful: They form a Turing-complete compile-time sub-language. However, that power isn’t needed for swap. Note that the C++ standard library already provides a swap function which contains optimized implementations for standard library types; thus it’s advisable to use that instead of a self-written variant like the one below.

While the standard allows to separate declaration and definition of templates into different files using the export keyword, most compilers (including the most used ones) don’t implement that. Therefore in practice, templates declared in header files also have to be defined there.

The implementation of the swap function template is straightforward:

template<typename T> void swap(T& left, T& right)
{
	T tmp(left);
	left = right;
	right = tmp;
}

Note that this function requires that the type T has an accessible copy constructor and assignment operator.

The standard utility ‘swap’ can be used to swap two values:

std::swap(x,y);

It will work with any types.

C++11 adds move constructors which can be more efficient than copy constructors.

template<class T>
void swap(T &lhs, T &rhs){
	T tmp = std::move(lhs);
	lhs = std::move(rhs);
	rhs = std::move(tmp);
}

SOURCE

Content is available under GNU Free Documentation License 1.2.