Template Metaprogramming

Use of CeePlusPlus templates to execute code at CompileTime.

SmugLispWeenies will no doubt view this as an inefficient reinvention of LispMacros. They are correct of course, templates aren't nearly as powerful as macros, and I'm not a LispWeenie?.

• Before this leads to later confused responses: they are both TuringEquivalent, but Lisp macros are exactly as expressive as regular Lisp functions, whereas C++ templates are much less expressive than the rest of C++; they must be used in strange and kludgy ways in order to achieve general computations beyond what they were nominally designed for. This is partly because C++ is not a HomoiconicLanguage.
• See also CeePlusPlusTemplatesCommonLispMacrosComparison.

• As another non-LispWeenie?, I have to say that Templates were a very nice try by some hard working people, but the fact that people have fallen into the TuringTarpit with them has proven that they were insufficient. Anything less than a fully expressive macro language will inevitably have shortcomings. Fundamentally, the problem is that there are so many problems that can be solved in OOP metaprogramming by, on being given type T1,
  • Define type T2
  • Iterate across the members of T1, create wrappers of them and add them to type T2
  • all at compile time.

Consider how much can happen once you can iterate across the members/methods. Implementing garbage-collected classes becomes possible. Forwarding access to methods becomes simple. C++ is a very nice language, why can't I just code my macros and templates in it? If so, classes could simply be objects at compile time - a class would contain an array of method-describing structs, an array of member-describing-structs, etc. You could iterate across this and use the information for the glorified mess of string parsing that is the actual process of creating the templated class. If the "class" object included some way to be converted into an aggregate, then implementing reflection becomes simply taking each given class and adding a static "type" member and a dynamic "getType" operation. Why should Lisp be the only language where macros and code are written in the same (or similar) dialects? Even if it was just a modified version (like allowing easier emission of code and forcing class-defining operations to be functional) of C++ for macros, it would be better than anything else. You can do all of this in C#, but it's at run-time so you lose the speed advantage and the static type-checking, making calling operations on your generated classes a massive pain. Simply put: if your language isn't good enough to define your own programs in, why is it good enough for the logic itself? --MartinZarate

See http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html

KrzysztofCzarnecki? and UlrichEisenecker?'s GenerativeProgrammingBook is a wonderful tour of the world of generative programming. Much of it is devoted to demonstrating the power of the CeePlusPlus template mechanism. They observe that it is a TuringComplete language that allows a C++ program to manipulate itself at compile time. They go on to show how to build the elements of structured programming (if, switch, while, for) and a lisp processor (cons, car, cdr, ...).

The C++ StandardTemplateLibrary makes only very primitive use of the template mechanism. Programmers must specify their desires by explicitly choosing an implementation, rather than by describing their intent. Czarnecki and Eisenecker show how you can use templates to implement a DomainSpecificLanguage for a client's use: the template meta-program then constructs the appropriate implementation classes based on the preferences.

Another area they explore is optimization. They have been involved in the development of the MatrixTemplateLibrary (MTL). Using templates to define LazyEvaluation at compile time, they show how a matrix expression such as (a+b)*(c+d) can be optimized at compile-time by a suitable Template Metaprogram: the expression is compiled into expression objects which are optimized (re-structured) by the templates. The restructured expression objects are evaluated when the result is assigned. (See ExpressionTemplate.)

There's much more to the book than C++ templates: they discuss a range of methods and languages for generative software (I found the first couple of chapters a bit tedious). They make a strong case for the limitations of today's component technologies. They give a thorough review of Microsoft's IntentionalProgramming research http://www.research.microsoft.com/IP). But their practical examples are written in C++. I had thought I understood templates: now I know how much I had missed.

--DaveWhipp.

---

BlitzPlusPlus uses a lot of template metaprograms. The PatternTemplateLibrary? also has some interesting, though convoluted, use of parameterization.

---

DaixtroseLib is a CeePlusPlus header library that retakes ideas developed by ToddVeldhuizen? and GeoffreyFurnish?. DaixtroseLib is ExpressionTemplates for everyone. With the help of this library the ExpressionTemplate technique now is available for everyone. DaixtroseLib takes the task of delaying the evaluation and building the expressions, such that users only have to provide the appropriate evaluation methods and by this can plug any existing class into the ExpressionTemplate context. The library offers fine-grained control over disambiguation rules and copy/reference semantics and was designed to have other libraries built on top of it. --MarkusWerle

---

See http://arxiv.org/html/cs.CL/0104010

---

Other books: CppTemplatesTheCompleteGuide by DavidVandevoorde? and NicolaiJosuttis?, ModernCeePlusPlusDesign, CppTemplateMetaprogramming, which describes BoostMpl (MPL).

---

CategoryCpp CategoryCppTemplates CategoryMetaprogramming CategoryLanguageFeature TemplateMetaprogrammingTechniques