4.4 Auxiliary Functions

template <class T, class Compare> inline const T& max (const T& a, const T& b, Compare comp) { return comp(a,b) ? b : a; } }
The comparison argument might be a function or a function object that compares both arguments and returns whether the first is less than the second in some particular order (function objects are introduced in Section 5.9).
I l@ve RuBoard
4.4 Auxiliary Functions
The algorithm library (header file <algorithm>) includes three auxiliary functions, one each for the selection of the minimum and maximum of two values and one for the swapping of two values. 4.4.1 Processing the Minimum and Maximum The functions to process the minimum and the maximum of two values are defined in <algorithm> as follows:
//overloaded global swap() for this type inline void swap (MyContainer& c1, MyContainer& c2) { c1. swap (c2); //calls implementation of swap()
3
}
So, calling swap() instead of swapping the values directly might result in substantial performance improvements. You should always offer a specialization of swap() for your own types if doing so has performance advantages.
//call max() with special comparison function pmax = max (px, py, int_ptr_less); ... }
Note that the definition of min() and max() require that both types match. Thus, you can't call them for objects of different types: inti; long l; ... l = std::max(i,l) ;
If both values are equal, generally the first element gets returned. However, it is not good programming style to rely on this. Both functions are also provided with the comparison criterion as an additional argument: namespace std { template <class T, class Compare> inline const T& min (const T& a, const T& b, Compare comp) { return comp(b,a) ? b : a; }
/* function that compares two pointers by comparing the values to which t */ bool int_ptr_less (int* a, int* b) { return *a < *b; }
int main() { int x = 17; int y = 42; int* px = &x; int* py = &y; int* pmax;
I l@ve RuBoard
4ห้องสมุดไป่ตู้
namespace std { template<class T> inline void swap(T& a, T& b) { T tmp(a); a = b; b = trap; } }
By using this function you can have two arbitrary variables x and y swap their values by calling std::swap(x,y);
Of course, this call is possible only if the copy constructions and assignments inside the swap() function are possible. The big advantage of using swap() is that it enables to provide special implementations for more complex types by using template specialization or function overloading. These special implementations might save time by swapping internal members rather than by assigning the objects. This is the case, for example, for all standard containers (Section 6.1.2) and strings (Section 11.2.8). For example, a swap() implementation for a simple container that has only an array and the number of elements as members could look like this: class MyContainer { private: int* elems; //dynamic array of elements int numElems; //number of elements public: ... //implementation of swap() void swap(MyContainer& x) { std::swap(elems,x.elems); std::swap(numElems,x.numElems); } ... };
//ERROR: argument types don't match
However, you could qualify explicitly the type of your arguments (and thus the return type): l = std::max<long>(i,l) ;
1
The following example shows how to use the maximum function by passing a special comparison function as an argument:
// util/minmax1.cpp #include <algorithm> using namespace std;
namespace std { template <class T> inline const T& min (const T& a, const T& b) { return b < a ? b : a; }
template <class T> inline const T& max (const T& a, const T& b) { return a < b ? b : a; } }
//OK
4.4.2 Swapping Two Values
2
The function swap() is provided to swap the values of two objects. The general implementation of swap() is defined in <algorithm> as follows: