{"id":8030,"date":"2025-11-29T09:10:33","date_gmt":"2025-11-29T08:10:33","guid":{"rendered":"https:\/\/web-dev-weissblau.de\/microconsult\/?p=8030"},"modified":"2026-02-11T05:58:04","modified_gmt":"2026-02-11T04:58:04","slug":"programming-at-compile-time","status":"publish","type":"post","link":"https:\/\/www.microconsult.de\/en\/programmierung-zur-compilezeit\/","title":{"rendered":"Compile-time programming"},"content":{"rendered":"

Autor: Rainer Grimm<\/p>\n

Beitrag – Embedded Software Engineering Kongress 2015<\/h3>\n

Was haben klassische Template-Metaprogrammierung, die Funktionen der Type-Traits-Bibliothek und konstante Ausdr\u00fccke gemein? Sie werden alle zur Compilezeit ausgef\u00fchrt. Damit vereinen sie h\u00f6here Performanz mit erweiterter Funktionalit\u00e4t. H\u00f6here Performanz, da Berechnungen zur Lauf- auf die Compilezeit verlegt werden. Erweiterte Funktionalit\u00e4t, da Programmierung zur Compilezeit den resultierenden C++-Sourcecode modifizieren kann. Doch wie funktioniert die ganze Magie?<\/strong><\/p>\n

Template-Metaprogrammierung<\/h2>\n

1994 entdeckte Erwin Unruh Template Metaprogrammierung durch einen Zufall. Sein Programm berechnete die ersten 30 Primzahlen zur Compilezeit. Die Ausgabe der Primzahlen war Teil der Fehlermeldung:<\/p>\n

01 | Type `enum{}‘ can’t be converted to txpe `D<2>‘ („primes.cpp“,L2\/C25).<\/p>\n

02 | Type `enum{}‘ can’t be converted to txpe `D<3>‘ („primes.cpp“,L2\/C25).<\/p>\n

03 | Type `enum{}‘ can’t be converted to txpe `D<5>‘ („primes.cpp“,L2\/C25).<\/p>\n

04 | Type `enum{}‘ can’t be converted to txpe `D<7>‘ („primes.cpp“,L2\/C25).<\/p>\n

05 | Type `enum{}‘ can’t be converted to txpe `D<11>‘ („primes.cpp“,L2\/C25).<\/p>\n

06 | Type `enum{}‘ can’t be converted to txpe `D<13>‘ („primes.cpp“,L2\/C25).<\/p>\n

07 | Type `enum{}‘ can’t be converted to txpe `D<17>‘ („primes.cpp“,L2\/C25).<\/p>\n

08 | Type `enum{}‘ can’t be converted to txpe `D<19>‘ („primes.cpp“,L2\/C25).<\/p>\n

09 | Type `enum{}‘ can’t be converted to txpe `D<23>‘ („primes.cpp“,L2\/C25).<\/p>\n

10 | Type `enum{}‘ can’t be converted to txpe `D<29>‘ („primes.cpp“,L2\/C25).<\/p>\n

Wie funktioniert die ganze Magie? Der Compiler instanziiert die Templates und erzeugt den tempor\u00e4ren C++ Sourceode, der zusammen mit dem restlichen Sourcecode \u00fcbersetzt wird. Zur Laufzeit des Programmes steht damit nur der ausf\u00fchrbare Code zur Verf\u00fcgung.<\/p>\n

So f\u00fchrt der Aufruf der Fakult\u00e4t Funktion\u00a0Factorial<5>::value<\/span>\u00a0in dem kleinen Codebeispiel dazu, dass der Wert zur Compilezeit berechnet wird.<\/p>\n

template <int N><\/p>\n

struct Factorial{<\/p>\n

\u00a0\u00a0\u00a0 static int const value= N * Factorial<N-1>::value;<\/p>\n

};<\/p>\n

template <><\/p>\n

struct Factorial<1>{<\/p>\n

\u00a0\u00a0\u00a0 static int const value = 1;<\/p>\n

};<\/p>\n

std::cout << Factorial<5>::value << std::endl;<\/p>\n

std::cout << 120 << std::endl;<\/p>\n

\n

Sch\u00f6n zeigt die folgende Abbildung (siehe\u00a0PDF<\/a>), dass der Wert der Fakult\u00e4t von 5 bereits zur Laufzeit als Konstante vorliegt. Dabei instanziiert der Compiler den Ausdruck\u00a0Factorial<5>::value<\/span>. Um diesen Wert zu berechnen, ben\u00f6tigt er den Ausdruck\u00a0Factorial<4>::value<\/span>. Diese Rekursion endet dann, wenn der Wert\u00a0Factorial<1>::value<\/span>\u00a0ben\u00f6tigt wird, denn deren Wert ist 1.<\/p>\n

Funktionen wie die\u00a0Factorial\u00a0<\/span>Funktion, die zur Compilezeit ausgef\u00fchrt werden, werden Metafunktionen genannt. Sie besitzen ein paar interessante Eigenschaften. Neben Ganzzahlen k\u00f6nnen sie auch Typen und Klassen-Typen als Template-Parameter verwenden. Metafunktionen sind unter der Decke Klassen-Templates. Sie k\u00f6nnen ihre Daten nicht modifizieren, sondern erzeugen auf Bedarf neue Daten.<\/p>\n

Template-Metaprogrammierung, die auf Metafunktion basiert, die zur Compilezeit auf ihren Metadaten agieren, ist eine rein funktionale Subsprache in der imperativen Sprache C++. Diese funktionale Subsprache ist Turing-vollst\u00e4ndig [1], und entspricht in ihrer M\u00e4chtigkeit der der Programmiersprachen C++, C oder Java.<\/p>\n

Template Metaprogrammierung ist die Grundlage f\u00fcr viele Boost-Bibliotheken [2]. Das trifft auch auf die Type-Traits Bibliothek zu, die seit C++11 Teil des C++-Standards ist.<\/p>\n

Die Type-Traits Bibliothek<\/h2>\n

Die Type-Traits Bibliothek erlaubt es, Typabfragen, -vergleiche und -transformationen zur Compilezeit auszuf\u00fchren. Sie ist eine Anwendung der Template-Metaprogrammierung und verfolgt for allem zwei Zwecke: Korrektheit und Optimierung:<\/p>\n

Korrektheit<\/strong><\/p>\n

Die Type-Traits Bibliothek erlaubt es in Kombination mit dem\u00a0static_assert<\/span>\u00a0Ausdruck, verbindliche Bedingungen an den Sourcecode zu stellen, die zur Compilezeit angewendet werden.<\/p>\n

Der\u00a0qcd<\/span>-Algorithmus zur Berechnung des gr\u00f6\u00dften gemeinsamen Teilers zweier Ganzzahlen ist viel zu generisch. So l\u00e4sst er sich zwar mit Flie\u00dfkommazahlen, Strings und unterschiedlichen Datentypen wie\u00a0int (100)\u00a0<\/span>und\u00a0long int\u00a0<\/span>(10L) verwenden. Der Compiler quittiert dies aber mit einer sehr wortreichen Fehlermeldung.<\/p>\n

#include <iostream><\/p>\n

#include <type_traits><\/p>\n

template<typename T><\/p>\n

T gcd(T a, T b){<\/p>\n

\u00a0 if( b == 0 ) return a;<\/p>\n

\u00a0 else return gcd(b, a % b);<\/p>\n

}<\/p>\n

int main(){<\/p>\n

\u00a0 std::cout << gcd(100,10) << std::endl;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/\u00a0 10<\/p>\n

\u00a0 std::cout << gcd(100,33) << std::endl;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/\u00a0 1<\/p>\n

\u00a0 std::cout << gcd(100,0) << std::endl;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/\u00a0 100<\/p>\n

\u00a0\u00a0std::cout << gcd(3.5,4.0) << std::endl;\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ ERROR<\/p>\n

\u00a0 std::cout << gcd(„100″,“10“) << std::endl;\u00a0\u00a0\u00a0 \/\/ ERROR<\/p>\n

\u00a0 std::cout << gcd(100,10L) << std::endl;\u00a0\u00a0\u00a0\u00a0 \u00a0\u00a0\/\/ ERROR<\/p>\n

}<\/p>\n<\/div>\n

<\/div>\n
Durch die Type-Traits Bibliothek lassen sich die Bedingungen an den Algorithmus explizit stellen. Und das alles ohne zus\u00e4tzliche Kosten f\u00fcr die Laufzeit des Programmes.<\/div>\n
<\/div>\n
\n

template<typename T1, typename T2><\/p>\n

typename\u00a0std::conditional<(sizeof(T1)<sizeof(T2)),T1,T2>::type\u00a0gcd(T1 a, T2 b){<\/p>\n

\u00a0 static_assert(std::is_integral<T1>::value, „T1 should be integral!“);<\/p>\n

\u00a0 static_assert(std::is_integral<T2>::value, „T2 should be integral!“);<\/p>\n

\u00a0 if( b == 0 )return a;<\/p>\n

\u00a0 else return gcd(b, a % b);<\/p>\n

}<\/p>\n

So pr\u00fcft der neue\u00a0qcd<\/span>-Algorithmus, ob die beiden Template-Argumente T1 und T2 Ganzzahlen sind:\u00a0std::is_integral<T1>::value.\u00a0<\/span>Als R\u00fcckgabetyp f\u00fcr den gr\u00f6\u00dften gemeinsamen Teiler gibt der\u00a0qcd<\/span>-Algorithmus den kleineren der beiden Typen zur\u00fcck:\u00a0std::conditional<(sizeof(T1)<sizeof(T2)),T1,T2>::type.<\/span><\/p>\n

Optimierung<\/strong><\/p>\n

Code zu schreiben, der sich beim \u00dcbersetzen selbst optimiert, das erlaubt die Type-Traits Bibliothek. So enth\u00e4lt die Standard Template Library (STL) optimierte Versionen der bekannten Algorithmen\u00a0std::copy, std::fill oder std::equal.\u00a0<\/span><\/p>\n

Die Idee ist recht einfach. Immer, wenn die Algorithmen auf Container agieren, deren Elemente hinreichend einfach sind, kommt ein optimierter Algorithmus zum Einsatz. Damit ist es m\u00f6glich, die Elemente nicht elementweise zu kopieren (std::copy<\/span>), zu f\u00fcllen (std::fill<\/span>) oder zu vergleichen (std::equal<\/span>), sondern ganze Containerbereiche zu bearbeiten. Daf\u00fcr kommen die C-Funktionen\u00a0memmove<\/span>,\u00a0memset<\/span>\u00a0und\u00a0memcpy<\/span>\u00a0zum Einsatz.<\/p>\n

Ob die Containerelemente hinreichend einfach sind, entscheiden zur Compilezeit die Funktionen der Type-Traits Bibliothek.<\/p>\n

template <typename I, typename T, bool b><\/p>\n

void fill_impl(I first,I last,const T& val,<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0const std::integral_constant<bool, b>&){<\/p>\n

\u00a0\u00a0 while(first != last){<\/p>\n

\u00a0\u00a0\u00a0 *first = val;<\/p>\n

\u00a0\u00a0\u00a0 ++first;<\/p>\n

\u00a0 }<\/p>\n

}<\/p>\n

template <typename T><\/p>\n

void fill_impl(T* first, T* last, const T& val,\u00a0const std::true_type&){<\/p>\n

\u00a0\u00a0std::memset(first, val, last-first);<\/p>\n

}<\/p>\n

template <class I, class T><\/p>\n

inline void fill(I first, I last, const T& val){<\/p>\n

\u00a0 typedef\u00a0integral_constant<bool,is_trivially_copy_assignable<T>::value<\/p>\n

\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 && (sizeof(T) == 1)> boolType;<\/p>\n

\u00a0 fill_impl(first, last, val,\u00a0boolType());<\/p>\n

}<\/p>\n

 <\/p>\n

Wird\u00a0std::fill<\/span>\u00a0aufgerufen, verwendet der Compiler die Implementierungsfunktion fill_impl mit std::memset genau dann, wenn die Elemente des Containers einen vom Compiler automatisch erzeugten Kopierkonstruktor besitzen und ein Byte gro\u00df sind:\u00a0is_trivially_copy_assignable<T>::value && (sizeof(T) == 1.<\/span><\/p>\n

Der Performanzunterschied ist signifikant. So wird in dem Programm ein Array mit 100.000.000 Elementen gef\u00fcllt.<\/p>\n

 <\/p>\n

const int arraySize = 100’000’000;<\/p>\n

char charArray1[arraySize]= {0,};<\/p>\n

char charArray2[arraySize]= {0,};<\/p>\n

int main(){<\/p>\n

\u00a0 auto begin= std::chrono::system_clock::now();<\/p>\n

\u00a0\u00a0fill(charArray1, charArray1 + arraySize,1);<\/p>\n

\u00a0 auto last= std::chrono::system_clock::now() – begin;<\/p>\n

\u00a0 cout << „charArray1: “ << duration<double>(last).count() << “ seconds“;<\/p>\n

\u00a0 begin= std::chrono::system_clock::now();<\/p>\n

\u00a0\u00a0fill(charArray2, charArray2 + arraySize, static_cast<char>(1));<\/p>\n

\u00a0 last= std::chrono::system_clock::now() – begin;<\/p>\n

\u00a0 cout << „charArray2: “ << duration<double>(last).count() << “ seconds“;<\/p>\n

}<\/p>\n

 <\/p>\n

W\u00e4hrend die Elemente des\u00a0charArray1<\/span>\u00a0mit der Zahl 1 initialisiert werden, die in der Regel 4 oder 8 Byte gro\u00dfe ist, wird charArray2 mit einer char initialisiert:\u00a0static_cast<char>(1). \u00a0<\/span><\/p>\n

Die performante Version des Algorithmus ist um den Faktor 20 schneller (siehe Abbildung,\u00a0PDF-Datei<\/a>).<\/p>\n

Konstante Ausdr\u00fccke<\/strong><\/p>\n

Konstante Ausdr\u00fccke k\u00f6nnen zur Compilezeit evaluiert und im ROM gespeichert werden. Sie geben dem Compiler tiefen Einblick in den Sourcecode und sind implizit threadsicher.<\/p>\n

Konstante Ausdr\u00fccke gibt es als Variablen, benutzerdefinierte Typen und Funktionen. Im Gegensatz zu Template-Metaprogrammierung erlauben sie das Programmieren zur Compilzeit im imperativen Stil. Damit konstante Ausdr\u00fccke zur Compilezeit evaluiert werden k\u00f6nnen, gilt es ein paar Regeln zu beachten.<\/p>\n