Vector Iteration

C++ vectors have many functions which allow element iteration.

Some of them are:

• for_each
• transform
• copy_if
• all_of
• accumulate

To use for_each, transform, copy_if and all_of the package <algorithm> needs to be included.

To use accumulate the package <numeric> needs to be included.

for_each

Iterates the elements of a vector.

It accepts the following arguments:

• start iterator
• end iterator
• function

Let's look at the following example:

#include <iostream> #include <vector> #include <algorithm> using namespace std; void printNumber(int num) { cout << "Value: " << num << endl; cout << "- - - - - - - -" << endl; } int main() { vector<int> numbers = { 4, 8, 7, 6, 3 }; for_each(numbers.begin(), numbers.end(), printNumber); return 0; }

Output:

Value: 4 - - - - - - - - Value: 8 - - - - - - - - Value: 7 - - - - - - - - Value: 6 - - - - - - - - Value: 3 - - - - - - - -

The code snippet prints all values of the vector in a way specified in the printNumber function.

There is another way to specify the function argument like this:

#include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { vector<int> numbers = { 4, 8, 7, 6, 3 }; for_each(numbers.begin(), numbers.end(), [](int value) { cout << "Value: " << value << endl; cout << "- - - - - - - -" << endl; }); return 0; }

Output:

Value: 4 - - - - - - - - Value: 8 - - - - - - - - Value: 7 - - - - - - - - Value: 6 - - - - - - - - Value: 3 - - - - - - - -

This way we don't have to define a separate function in the global scope.

Certain elements can also be skipped from iteration using the iterators parameters.

Example:

#include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { vector<int> numbers = { 4, 8, 7, 6, 3 }; for_each(numbers.begin() + 2, numbers.end() - 1, [](int value) { cout << "Value: " << value << endl; cout << "- - - - - - - -" << endl; }); return 0; }

Output:

Value: 7 - - - - - - - - Value: 6 - - - - - - - -

In this case numbers.begin() + 2 skips the first 2 elements of the vector - 4 and 8.

numbers.end() - 1 skips the last element of the vector - 3.

So the only iterated elements are 7 and 6.

transform

Modifies vector's elements in a way returned by the function argument.

It accepts the following arguments:

• start iterator of the iterated vector
• end iterator of the iterated vector
• start iterator of the vector which elements will be modified.
• function

#include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { vector<int> numbers = { 4, 8, 7, 6, 3 }; transform(numbers.begin(), numbers.end(), numbers.begin(), [](int value) { return value * 2; }); for (int num : numbers) { cout << num << " "; } return 0; }

Output:

8 16 14 12 6

In this case, the modification is specified according to the returned value - value * 2.

copy_if

Allows filtering specific elements.

If the function argument returns true, the element will be present.

If the function argument returns false, it will not be present.

#include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { vector<int> numbers = { 4, 8, 7, 6, 3 }; vector<int> evenNumbers; copy_if(numbers.begin(), numbers.end(), back_inserter(evenNumbers), [](int value) { return value % 2 == 0; }); for (int element : evenNumbers) { cout << element << " "; } return 0; }

Output:

4 8 6

In order to access the filtered vector elements the back_inserter function is used to set their values in a separate vector.

all_of

Allows checking if all elements match a certain condition.

If all of the elements match the condition specified in the function argument, then the all_of function returns true. Otherwise, it returns false.

#include <iostream> #include <vector> #include <algorithm> using namespace std; int main() { vector<int> numbers = { 4, 8, 7, 6, 3 }; vector<int> onlyEvenNumbers = { 4, 8, 6 }; bool result1 = all_of(numbers.begin(), numbers.end(), [](int value) { return value % 2 == 0; }); bool result2 = all_of(onlyEvenNumbers.begin(), onlyEvenNumbers.end(), [](int value) { return value % 2 == 0; }); cout << result1 << endl; cout << result2 << endl; return 0; }

Output:

0 1

accumulate

Accumulates a single value based on the function argument.

It has 4 arguments:

• start iterator
• end iterator
• initial value
• function

#include <iostream> #include <vector> #include <numeric> using namespace std; int main() { vector<int> numbers = { 1, 2, 3, 4, 5 }; int sum = accumulate(numbers.begin(), numbers.end(), 0, [](int total, int value) { cout << "Accumulated value: " << total << endl; cout << "The value to add: " << value << endl; cout << "- - - - - - - - - -" << endl; return total + value; }); cout << "Sum: " << sum << endl; return 0; }

Output:

Accumulated value: 0 The value to add: 1 - - - - - - - - - - Accumulated value: 1 The value to add: 2 - - - - - - - - - - Accumulated value: 3 The value to add: 3 - - - - - - - - - - Accumulated value: 6 The value to add: 4 - - - - - - - - - - Accumulated value: 10 The value to add: 5 - - - - - - - - - - Sum: 15

The value returned by the accumulate function is based on the return statement of the function argument.

value is the iterated element - 1, 2, 3, 4, 5