Production-grade skill for C++ template programming and metaprogramming. Covers function/class templates, variadic templates, SFINAE, concepts, type traits, and compile-time computation.
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
Der Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.
Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.
Datei-Explorer
6 Dateien
SKILL.md wird angezeigt
SKILL.md
Quellanweisungen · Schreibgeschützte Vorschau
name
templates
version
3.0.0
description
Production-grade skill for C++ template programming and metaprogramming. Covers function/class templates, variadic templates, SFINAE, concepts, type traits, and compile-time computation.
sasmp_version
1.3.0
skill_version
3.0.0
bonded_agent
01-modern-cpp-expert
bond_type
PRIMARY_BOND
category
development
parameters
{"template_type":{"type":"string","required":false,"enum":["function","class","variable","alias","concept"],"description":"Type of template to work with"},"metaprogramming_level":{"type":"string","required":false,"enum":["basic","intermediate","advanced"],"default":"intermediate","description":"Complexity level of metaprogramming"},"cpp_standard":{"type":"string","required":false,"enum":["cpp11","cpp14","cpp17","cpp20","cpp23"],"default":"cpp20","description":"Target C++ standard"}}
Production-Grade Development Skill | C++ Template Metaprogramming
Master C++ template programming from basics to advanced metaprogramming techniques.
Template Basics
Function Templates
// Basic function templatetemplate<typename T>
T max(T a, T b){
return (a > b) ? a : b;
}
// Multiple template parameterstemplate<typename T, typename U>
autoadd(T a, U b) -> decltype(a + b){
return a + b;
}
// C++20: Abbreviated function templateautomultiply(auto a, auto b){
return a * b;
}
// Non-type template parametertemplate<typename T, std::size_t N>
constexpr std::size_tarray_size(T (&)[N]){
return N;
}
// Template argument deductionmax(1, 2); // T = intmax(1.0, 2.0); // T = doublemax<double>(1, 2);
// Unary right fold: (pack op ...)template<typename... Args>
autosum(Args... args){
return (args + ...); // ((a + b) + c) + d...
}
// Unary left fold: (... op pack)template<typename... Args>
autosum_left(Args... args){
return (... + args); // a + (b + (c + d...))
}
// Binary fold with inittemplate<typename... Args>
autosum_with_init(Args... args){
return (0 + ... + args); // 0 + a + b + c...
}
// Logical foldstemplate<typename... Args>
boolall(Args... args){
return (... && args); // All true
}
template<typename... Args>
boolany(Args... args){
return (... || args); // Any true
}
// Comma fold for side effectstemplate<typename F, typename... Args>
voidfor_each_arg(F f, Args&&... args){
(f(std::forward<Args>(args)), ...);
}
SFINAE and enable_if
SFINAE Basics
#include<type_traits>// Enable only for integral typestemplate<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
safe_divide(T a, T b){
return b != 0 ? a / b : 0;
}
// C++14 styletemplate<typename T>
std::enable_if_t<std::is_floating_point_v<T>, T>
safe_divide(T a, T b) {
return b != T{0} ? a / b : std::numeric_limits<T>::quiet_NaN();
}
// Using void_t for detection idiomtemplate<typename, typename = void>
struct has_size : std::false_type {};
template<typename T>
structhas_size<T, std::void_t<decltype(std::declval<T>().size())>>
: std::true_type {};
// Usagestatic_assert(has_size<std::vector<int>>::value);
static_assert(!has_size<int>::value);
#include<concepts>// Using standard conceptstemplate<std::integral T>
T gcd(T a, T b){
while (b != 0) {
T t = b;
b = a % b;
a = t;
}
return a;
}
// Common standard conceptstemplate<std::floating_point T>
T sqrt_approx(T x);
template<std::copyable T>
voidprocess(T value);
template<std::invocable<int> F>
voidapply(F&& func);
template<std::ranges::range R>
voiditerate(R&& range);
