Summary - Concepts

Combine concept, requires and standard concepts to write a generic algorithm.

Summary - Concepts

In this group you learned concept, requires, standard concepts, compound requirement and concept overloading.

Concepts name template constraints; the requires expression does compile-time expression checks; std::integral and std::floating_point are ready-made concepts; compound requirements also check the return type and the noexcept condition; concept overloading dispatches type-based overloads at compile time.

Now you will write a generic accumulate algorithm that combines these four. It will be a safe and readable template built with concepts.

Exercise Write a generic accumulate

Write the template function template<std::integral T> T accumulate(const std::vector<T>& data). Its body sums the data and returns it. In main create std::vector<int> data{1, 2, 3, 4}; and print the result of accumulate(data) with std::cout.

Show example solution

#include <iostream>
#include <vector>
#include <concepts>

template<std::integral T>
T accumulate(const std::vector<T>& data) {
    T sum = T{0};
    for (auto x : data) {
        sum += x;
    }
    return sum;
}

int main() {
    std::vector<int> data{1, 2, 3, 4};
    std::cout << accumulate(data);
    return 0;
}

Test yourself

Which keyword starts a concept definition?
- template
- static_assert
- concept
- requires
Show answer

concept — The concept keyword starts a concept definition.
Match each idea to its description

concept

Named constraint
requires

Expression check
std::integral

Ready integral concept
compound

Return type check

the accumulate call

std::cout << ____(data.begin(), data.end());

Show answer

std::cout << accumulate(data.begin(), data.end());

Next lesson: What are coroutines?

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies