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;
}

Named constraints make the interface easier to read and keep failures closer to the call site.

Useful standard traits

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

template <typename T>
void describe(T&& value) {
    using Raw = std::remove_cvref_t<T>;
    if constexpr (std::is_integral_v<Raw>) {
        std::cout << "integral\n";
    }
}

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);
}

Debugging template errors

• Start with the first failed requirement, not the full wall of instantiation output.
• Give recurring constraints names instead of repeating long requires expressions.
• Prefer concepts in public interfaces so misuse fails at the boundary instead of deep inside implementation code.

template <std::integral T>
T twice(T value) {
    return value + value;
}

auto text = twice(std::string{"Ada"});

The fix is not to stare at the whole compiler trace. The fix is to notice that std::string does not model std::integral.

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>

Pattern selection guide

• plain template: one algorithm works across many types
• concept-constrained template: the algorithm needs a clear interface contract
• if constexpr: one implementation has a few type-based branches
• type traits: implementation needs compile-time facts about the type

When if constexpr helps

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