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;
}
Advertisements
Dieser Beitrag wurde unter C++ veröffentlicht. Setze ein Lesezeichen auf den Permalink.

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden /  Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden /  Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden /  Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden /  Ändern )

w

Verbinde mit %s