Cpp Templates

C++ templates

Contract

Inputs

• Compiler, version, and -std=: required. Concepts need C++20; C++23 is the current standard and C++20 the floor.
• The full diagnostic text: required for error reading.
• The template and one call site: required for constraint work.
• A build with compile_commands.json or a single reproducing TU: required for profiling.

Procedure

1. Read the error from the bottom up. The first error: line names the user's call; the required from here (GCC) or in instantiation of (Clang) notes trace the chain; the last note names the type whose substitution failed. Shorten the chain with -ftemplate-backtrace-limit=N (GCC and Clang); with GCC add -fconcepts-diagnostics-depth=N for concept failures; with Clang add -fno-elide-type to print full types and -fdiagnostics-show-template-tree for a tree diff of the mismatch. Done when: the failing substitution and the call site are named.

2. Write the constraint with concepts when the standard is C++20 or later:

   template <typename T> concept Arithmetic = std::is_arithmetic_v<T>;
   template <typename T> concept Container = requires(T c) {
       c.begin(); c.end(); c.size(); typename T::value_type;
   };
   template <Arithmetic T> T square(T x) { return x * x; }
   auto square(Arithmetic auto x) { return x * x; }
   template <typename T> requires Arithmetic<T> && (sizeof(T) >= 4)
   T big_square(T x) { return x * x; }
   

   Requires-expression forms: expr; checks validity, { expr } -> std::same_as<U>; checks the result type, { expr } -> std::convertible_to<U>; checks convertibility, requires Other<T>; nests a constraint. Done when: the constraint expresses the operations the body uses and nothing more.

3. Recognize SFINAE in existing code and map it to a concept: std::enable_if_t<cond, int> = 0 on a parameter, -> std::enable_if_t<cond, R> on a return type, and the std::void_t<decltype(...)> detection idiom. Replace enable_if with a constraint and void_t detectors with a requires expression. Keep SFINAE only when the standard is below C++20. Done when: each SFINAE site has its concept equivalent or a reason to keep it.

4. Explain the trade-off when asked. Concepts give a named constraint failure at the call site, participate in overload ranking by subsumption, and read directly; SFINAE gives a wall of candidate notes and ranks by hand-built priority. Compile-time differences depend on the code; measure before claiming one. Done when: the comparison is stated without unmeasured speed claims.

5. Profile instantiation cost. Clang: -ftime-trace writes <object>.json per TU; aggregate a whole build with ClangBuildAnalyzer --start <dir>, build, ClangBuildAnalyzer --stop <dir> capture.bin, ClangBuildAnalyzer --analyze capture.bin, which lists the templates and template sets that took longest to instantiate. Templight, a Clang-based drop-in, traces every instantiation: templight++ -Xtemplight -profiler -Xtemplight -memory -Xtemplight -ignore-system -c src.cpp writes src.o.trace.pbf; it must be built from source with Clang. Done when: a measurement names the top instantiations.

6. Reduce the measured cost with the pattern that fits: explicit instantiation (extern template int f<int>(int); in the header, template int f<int>(int); in one TU); if constexpr in place of specialization; a constraint that rejects early instead of a deep substitution failure; splitting heavy template implementations into a header included only where needed. Done when: each proposed change is tied to an instantiation the profile named.

7. Confirm the rewrite compiles on the user's compiler and standard with a scratch TU before reporting. Done when: the scratch build passes.

Failure and recovery

Output

A chat report naming the failing instantiation and its cause, the constraint rewrite that compiled on a scratch TU, and, when compile time was the complaint, the measurement command and the instantiations it named with the matching reduction.