1#include <iostream>
2#include <vector>
3
4int main() {
5    std::vector<int> values{1, 2, 3, 4, 5};
6
7    for (int v : values) {
8        std::cout << v << "
9";
10    }
11}

1#include <algorithm>
2#include <iostream>
3#include <numeric>
4#include <vector>
5
6int main() {
7    std::vector<int> values{1, 2, 3, 4, 5, 6};
8
9    int sum_even = std::accumulate(values.begin(), values.end(), 0,
10        [](int acc, int v) {
11            return (v % 2 == 0) ? acc + v : acc;
12        });
13
14    std::cout << "sum_even=" << sum_even << "
15";
16}

1#include <iostream>
2#include <ranges>
3#include <vector>
4
5int main() {
6    std::vector<int> values{1, 2, 3, 4, 5, 6};
7
8    auto even_squares = values
9| std::views::filter([](int v) { return v % 2 == 0; }) | std::views::transform([](int v) { return v * v; }); for (int v : even_squares) { std::cout << v << " "; } } ``` This demonstrates that loops and algorithms are complementary rather than competing features. ## Performance and Readability Tradeoff Neither style is automatically faster in every case. Compilers often optimize both patterns well when code is straightforward. The bigger difference is maintainability: algorithm calls express intent in a compact, review-friendly way, while loops make stepwise logic explicit. A practical rule is to start with the clearest expression for the current task, then profile if performance matters. Premature micro-optimization around loop syntax rarely delivers meaningful gains compared with better data structures or algorithmic complexity improvements. ## Use Algorithms as a Shared Vocabulary Teams benefit when common operations use standard algorithm names such as `find_if`, `transform`, and `count_if`. Reviewers can understand intent quickly because the operation is encoded in the function name. This reduces cognitive load and lowers bug risk in collection processing code. Range-based loops remain valuable, especially when business logic requires branching and early exits. The two styles work best together. ## Refactor Example from Manual Loop to Algorithm A useful technique is to implement logic first with a loop, then refactor to an algorithm once behavior is clear. This helps teams keep correctness while improving expressiveness. ```cpp #include <algorithm> #include <iostream> #include <vector> int main() { std::vector<int> values{3, 8, 1, 9, 2}; // Manual loop int max_value = values.front(); for (int v : values) { if (v > max_value) { max_value = v; } } // Algorithm equivalent int max_with_algo = *std::max_element(values.begin(), values.end()); std::cout << max_value << " " << max_with_algo << " "; } ``` This side-by-side style is great for teaching and code review because it makes the algorithm choice obvious and verifiable. ## Common Pitfalls * Replacing clear algorithm calls with manual loops and losing semantic clarity. * Overusing clever range pipelines where a simple loop is easier to read. * Forgetting reference qualifiers in range-based loops and making unintended copies. * Assuming one style is always superior for performance without measurement. ## Summary * Range-based loops improve readability for direct iteration. * Algorithms remain valuable for expressive, reusable data operations. * C++ ranges combine both worlds in a composable style. * Choose the style that communicates intent most clearly.