Functions, overloads, templates, and concepts

A function signature defines argument types and ownership boundaries. Passing a large vector by value copies it; passing by const reference borrows it; passing by value can also be appropriate when the function intends to take ownership. Return a value for independently owned results and rely on normal return-value optimization rather than returning a reference to a local.

Int sum(std::span<const Int> values); // borrows any compatible contiguous sequence
void consume(std::vector<Int> values); // owns its parameter copy/move

Overload resolution chooses among viable signatures using conversion rankings. A generic overload can unexpectedly beat a non-template if it requires fewer conversions. Templates deduce types from expressions, not from runtime values. A constraint documents admissible operations and removes invalid candidates before instantiating a body; it cannot prove every semantic precondition.

template<class T>
concept ArithmeticInteger=std::integral<T> && !std::same_as<T,bool>;
// bool is integral in the type system, but is not meaningful for checked addition here.

A generic checked addition must account for different signedness. Unsigned overflow is detectable with a > max-b; for signed types, split on the sign of b and compare against max-b or min-b before adding. Computing a+b first already invokes undefined behavior for a signed overflow, so a later comparison is too late. Integer promotions also mean a narrow expression can have type int; explicitly return the chosen T only after proving the mathematical result is representable.

Header-defined templates must be visible at their instantiation sites. inline can resolve ordinary header function linkage, but does not mean the compiler must inline machine code. Keep constraints on the public declaration and implementation consistent.