Templates and Generics

Function templates

template <typename T>
T max_of(T a, T b) {
    return a > b ? a : b;
}

Class templates

template <typename T>
class Box {
public:
    explicit Box(T value) : value_{std::move(value)} {}
    const T& get() const { return value_; }

private:
    T value_;
};

Non-type template parameters

template <typename T, std::size_t N>
class FixedBuffer {
    std::array<T, N> data_{};
};

Concepts and requires

template <typename T>
concept Addable = requires(T a, T b) {
    a + b;
};

template <Addable T>
T sum(T a, T b) {
    return a + b;
}

Useful standard traits

• std::is_same_v<T, U>
• std::is_integral_v<T>
• std::enable_if_t<...>
• std::remove_reference_t<T>

Best-practice reminders

• Keep templates small and composable.
• Prefer concepts over cryptic SFINAE when available.
• Favor readable constraints and precise error messages.
• Avoid excessive metaprogramming if a simpler design works.

Abbreviated templates and named constraints

std::integral auto clamp_positive(std::integral auto value) {
    return value < 0 ? 0 : value;
}

Abbreviated templates are convenient for small interfaces, but named template parameters are usually clearer for bigger APIs.

requires clauses and nested requirements

template <typename T>
concept Reservable = requires(T container, std::size_t n) {
    container.reserve(n);
    typename T::value_type;
};

template <typename T>
requires Reservable<T>
void prepare(T& container, std::size_t n) {
    container.reserve(n);
}

Useful modern traits and helpers

• std::remove_cvref_t<T>
• std::type_identity_t<T>
• std::is_invocable_v<F, Args...>
• std::conditional_t<cond, A, B>

When if constexpr helps

Use if constexpr to keep one generic algorithm readable instead of splitting simple type-based branches into separate overloads.