Cpp Templates

#include <type_traits>
// Enable function only for arithmetic typestemplate <typename T,    std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>T square(T x) { return x * x; }
// SFINAE with return typetemplate <typename T>auto to_string(T x) -> std::enable_if_t<std::is_integral_v<T>, std::string> {    return std::to_string(x);}
// Void-t technique for detecting member existencetemplate <typename, typename = void>struct has_size : std::false_type {};
template <typename T>struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>    : std::true_type {};

#include <concepts>
// Define a concepttemplate <typename T>concept Arithmetic = std::is_arithmetic_v<T>;
template <typename T>concept Printable = requires(T x) {    { std::cout << x } -> std::same_as<std::ostream&>;};
template <typename T>concept Container = requires(T c) {    c.begin();    c.end();    c.size();    typename T::value_type;};
// Apply concept as constrainttemplate <Arithmetic T>T square(T x) { return x * x; }
// Abbreviated function template (C++20)auto square(Arithmetic auto x) { return x * x; }
// requires-clause (more complex conditions)template <typename T>    requires Arithmetic<T> && (sizeof(T) >= 4)T big_square(T x) { return x * x; }
// Concept in auto parametervoid print_container(const Container auto& c) {    for (const auto& elem : c) std::cout << elem << ' ';}

// requires { expression; } — checks expression is valid// requires { expression -> type; } — checks type of expression
template <typename T>concept HasPush = requires(T c, typename T::value_type v) {    c.push_back(v);                          // must be valid    { c.front() } -> std::same_as<typename T::value_type&>;  // type check    { c.size() } -> std::convertible_to<std::size_t>;        // convertible    requires std::default_initializable<T>;  // nested requirement};
// Compound requires (all must hold)template <typename T>concept Sortable = requires(T a, T b) {    { a < b } -> std::convertible_to<bool>;    { a == b } -> std::convertible_to<bool>;};

// 1. Explicit instantiation — compile once, use everywhere// header.htemplate <typename T>T transform(T x);
extern template int transform<int>(int);    // suppress instantiation
// impl.cpp#include "header.h"template int transform<int>(int);           // instantiate here only
// 2. Prefer function templates over class templates when possible// (functions instantiate lazily; class templates instantiate eagerly)
// 3. Use concepts to short-circuit failed substitutions// (concept check is faster than full substitution failure)
// 4. Split heavy template headers from lightweight ones// - Put type definitions in forward_decls.h// - Put template implementations in impl.h (include only where needed)
// 5. Use if constexpr instead of specializationtemplate <typename T>void process(T x) {    if constexpr (std::is_integral_v<T>) {        handle_int(x);    } else {        handle_other(x);    }}