## Operations which can be used in STL algorithms

Within the previous articles about STL algorithms I introduced the main algorithms sorted by their use case. Within this article I want to give an overview about the STL operations. These operations can be used stand-alone and within STL algorithms. The combination of the existing algorithms and operations will allow to solve complex implementations of some standard use cases in an easy way.

Compare two elements

 Algorithm Description equal_to Check whether the two elements are equal. not_equal_to Check whether the two elements are not equal. greater Check whether the first element is greater than the second one. less Check whether the first element is smaller than the second one. greater_equal Check whether the first element is greater or equal to the second one. less_equal Check whether the first element is smaller or equal to the second one. max Returns the larger one of the two elements. min Returns the smaller one of the two elements. minmax Returns a pair which contains the smaller element followed by the larger element.

Within the examples the operations “greater” and “less” are used to sort a container. The third example makes use of “max” operator to merge two containers by taking the maximum value of each element pair.

```void Print(const std::vector& data)
{
std::for_each(data.begin(), data.end(), [](int element){ std::cout << element << " "; });
std::cout << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
std::vector data{ 5, 7, 9, 2, 4 };

// greater
std::sort(data.begin(), data.end(), std::less());
Print(data);  // output is '2 4 5 7 9'

// less
std::sort(data.begin(), data.end(), std::greater());
Print(data);  // output is '9 7 5 4 2'

// max
std::vector data1{ 5, 7, 9, 2, 4 };
std::vector data2{ 3, 8, 1, 5, 8 };
std::vector target;
std::transform(data1.begin(), data1.end(),
data2.begin(), std::back_inserter(target),
[](int a, int b) {return std::max(a, b); });
Print(target);  // output is '5 8 9 5 8'

return 0;
}
```

Search elements in container

 Algorithm Description max_element Returns an iterator to the largest element of the container. min_element Returns an iterator to the smallest element of the container. minmax_element Returns a pair which contains an iterator to the smallest element of the container followed by an iterator to the largest element of the container.

```int _tmain(int argc, _TCHAR* argv[])
{
std::vector data{ 5, 7, 9, 2, 4 };

// max_element
auto iterator = std::max_element(data.begin(), data.end());
if (iterator != data.end())
{
std::cout << "max element " << *iterator << " found at index " << std::distance(data.begin(), iterator) << std::endl;
// output is 'max element 9 found at index 2'
}

return 0;
}
```

Calculations with one input

 Algorithm Description negate Returns the negation of the element. clamp Returns the given element with respect to a value range. If the given element is outside of the range the returned value will be equal to the lowest or highest boundary. Example: “clamp(x,20,30)” means the returned value must be in range 20 to 30. If x is less than 20 “20” will be returned. If x is between 20 to 30 “x” will be returned. If x is larger than 30 “30” will be returned.

```void Print(const std::vector& data)
{
std::for_each(data.begin(), data.end(), [](int element){ std::cout << element << " "; });
std::cout << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
std::vector data{ 5, -7, 9, -2, 4 };

// negate
std::transform(data.begin(), data.end(), data.begin(), std::negate());
Print(data);  // output is '-5 7 -9 2 -4'

return 0;
}
```

Calculations with two inputs

 Algorithm Description plus Returns the sum of the two elements. minus Returns the difference of the two elements. multiplies Returns the product of the two elements. divides Returns the quotient of the two elements. modulus Returns the residual value of the division of first element by second element. logical_and Returns the result of a logical-and calculation of the two elements. logical_or Returns the result of a logical-or calculation of the two elements. logical_not Returns the result of a logical-not calculation of the two elements. bit_and Returns the result of a bitwise-and calculation of the two elements. bit_or Returns the result of a bitwise-or calculation of the two elements. bit_xor Returns the result of a bitwise-xor calculation of the two elements. bit_not Returns the result of a bitwise-not calculation of the two elements.

```void Print(const std::vector& data)
{
std::for_each(data.begin(), data.end(), [](int element){ std::cout << element << " "; });
std::cout << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
std::vector source1{ 5, 7, 9, 2, 4 };
std::vector source2{ 3, 1, 2, 5, 7 };
std::vector target;

std::vector source3{ 1, 1, 0, 0 };
std::vector source4{ 1, 0, 1, 0 };

// sum
std::transform(source1.begin(), source1.end(), source2.begin(),
std::back_inserter(target), std::plus());

Print(target);  // output is '8 8 11 7 11'

// logical or
target.clear();

std::transform(source3.begin(), source3.end(), source4.begin(),
std::back_inserter(target), std::logical_or());

Print(target);  // output is '1 1 1 0'

// bitwise xor
target.clear();

std::transform(source3.begin(), source3.end(), source4.begin(),
std::back_inserter(target), std::bit_xor());

Print(target);  // output is '0 1 1 0'

return 0;
}
```
Dieser Beitrag wurde unter C++ veröffentlicht. Setze ein Lesezeichen auf den Permalink.

### Eine Antwort zu Operations which can be used in STL algorithms

1. Pingback: STL Algorithms | coders corner