テンプレートメタプログラミング

テンプレートメタプログラミング( TMP )は、コンパイラがテンプレートを使用して一時的なソースコードを生成するメタプログラミング手法です。この一時的なソースコードは、コンパイラによって残りのソースコードとマージされてコンパイルされます。これらのテンプレートの出力には、コンパイル時定数、データ構造、完全な関数が含まれます。テンプレートの使用は、コンパイル時ポリモーフィズムと考えることができます。この手法は多くの言語で使用されており、最もよく知られているのはC++ですが、Curl、D、Nim、XLなどでも使用されています。

テンプレートメタプログラミングは、ある意味では偶然に発見されました。^[1]^[2]

他の言語でも、同様の、あるいはより強力なコンパイル時機能 ( Lisp マクロなど) がサポートされていますが、それらはこの記事の範囲外です。

テンプレートメタプログラミングのコンポーネント

メタプログラミング手法としてテンプレートを使用するには、テンプレートを定義し、定義したテンプレートをインスタンス化するという 2 つの異なる操作が必要です。生成されたソースコードの汎用形式はテンプレート定義で記述され、テンプレートがインスタンス化されるときに、テンプレート内の汎用形式を使用して特定のソースコードセットが生成されます。

テンプレートメタプログラミングはチューリング完全であり、コンピュータプログラムで表現可能なあらゆる計算は、何らかの形でテンプレートメタプログラムによって計算できることを意味します。^[3]

テンプレートはマクロとは異なります。マクロはコンパイル時に実行されるコードの一部で、コンパイルされるコードのテキスト操作 ( C++マクロなど) を実行するか、コンパイラによって生成される抽象構文木( RustまたはLispマクロなど) を操作します。テキストマクロは、コンパイル直前にソースコードのメモリ内テキストを変更するだけなので、操作対象の言語の構文から独立していることが顕著です。

テンプレートメタプログラムには可変変数がありません。つまり、初期化された変数は値を変更できないため、テンプレートメタプログラミングは関数型プログラミングの一形態と見なすことができます。実際、多くのテンプレート実装では、以下の例に示すように、再帰のみでフロー制御を実装しています。

テンプレートメタプログラミングの使用

テンプレートメタプログラミングの構文は、通常、使用されるプログラミング言語とは大きく異なりますが、実用的な用途があります。テンプレートを使用する一般的な理由としては、汎用プログラミングを実装するため (若干の違いを除いて類似するコードセクションを回避する)、または、プログラムが実行されるたびにではなくコンパイル時に 1 回何かを実行するなど、コンパイル時の自動最適化を実行するため (たとえば、プログラムが実行されるたびにコンパイラにループを展開させてジャンプやループ数のデクリメントを排除する) などがあります。

コンパイル時のクラス生成

「コンパイル時のプログラミング」が具体的に何を意味するかは、階乗関数の例で説明できます。これは、テンプレートを使用しない C++ では、次のように再帰を使用して記述できます。

符号なし階乗(符号なしn ) { return n == 0 ? 1 : n *階乗( n - 1 ); }   
	            


// 使用例: 
// factorial(0) は 1 になります。
// factorial(4) は 24 になります。

上記のコードは実行時に実行され、リテラル 0 と 4 の階乗値を決定します。テンプレートメタプログラミングとテンプレート特殊化を使用して再帰の終了条件を提供することで、プログラムで使用される階乗 (使用されていない階乗は無視) を次のコードによってコンパイル時に計算できます。

テンプレート< unsigned N >構造体factorial { static constexpr unsigned value = N * factorial < N - 1 >:: value ; };  
  
	         


テンプレート<> struct factorial < 0 > { static constexpr unsigned value = 1 ; }; 
  
	     


// 使用例: 
// factorial<0>::value は 1 を返します。
// factorial<4>::value は 24 を返します。

上記のコードは、コンパイル時にリテラル 0 と 4 の階乗値を計算し、その結果を事前に計算された定数であるかのように使用します。この方法でテンプレートを使用できるようにするには、コンパイラがコンパイル時にパラメータの値を知っている必要があります。これには、X がコンパイル時にわかっている場合にのみ factorial<X>::value を使用できるという自然な前提条件があります。つまり、X は定数リテラルまたは定数式である必要があります。

C++11とC++20では、コンパイラがコードを実行できるようにconstexprとconstevalが導入されました。constexprとconstevalを使用すると、通常の再帰階乗定義をテンプレート化されていない構文で使用できます。^[4]

コンパイル時のコード最適化

上記の階乗の例は、プログラムで使用されるすべての階乗が事前にコンパイルされ、コンパイル時に数値定数として挿入されるという点で、コンパイル時のコード最適化の一例であり、実行時のオーバーヘッドとメモリフットプリントの両方を節約します。ただし、これは比較的小さな最適化です。

コンパイル時のループ展開のもう1つの重要な例として、テンプレートメタプログラミングを使用して長さnのベクトルクラスを作成できます（nはコンパイル時に既知です）。従来の長さnのベクトルに比べて、ループを展開できるため、非常に最適化されたコードになるという利点があります。例として、加算演算子を考えてみましょう。長さnのベクトルの加算は次のように記述できます。

テンプレート< int length > Vector < length >& Vector < length >:: operator += ( const Vector < length >& rhs ) { for ( int i = 0 ; i < length ; ++ i ) value [ i ] += rhs . value [ i ]; return * this ; }

コンパイラが上で定義された関数テンプレートをインスタンス化すると、次のコードが生成される場合があります。^{[引用が必要]}

テンプレート<> Vector < 2 >& Vector < 2 >:: operator += ( const Vector < 2 >& rhs ) { value [ 0 ] += rhs . value [ 0 ]; value [ 1 ] += rhs . value [ 1 ]; return * this ; }

forテンプレートパラメータはlengthコンパイル時に定数であるため、コンパイラのオプティマイザはループを展開できるはずです。

ただし、インスタンス化する「N」(ベクトルサイズ) ごとに個別の展開コードが生成されるため、コードが肥大化する可能性があるため、注意してください。

静的ポリモーフィズム

ポリモーフィズムは、派生オブジェクトをベースオブジェクトのインスタンスとして使用できる一般的な標準プログラミング機能ですが、このコードのように、派生オブジェクトのメソッドが呼び出されます。

クラスBase { public : virtual void method () { std :: cout << "Base" ; } virtual ~ Base () {} }; 


           
      


クラスDerived : public Base { public : virtual void method () { std :: cout << "Derived" ; } };    


           


int main () { Base * pBase = new Derived ; pBase -> method (); //「Derived」を出力しますdelete pBase ; return 0 ; }

ここで、メソッドのすべての呼び出しは、virtual最も派生したクラスのものになります。この動的ポリモーフィックな動作は、(通常) 仮想メソッドを持つクラスの仮想ルックアップテーブルを作成することによって実現されます。このテーブルは、実行時に走査され、呼び出されるメソッドを識別します。したがって、実行時のポリモーフィズムには、必然的に実行オーバーヘッドが伴います (ただし、最新のアーキテクチャではオーバーヘッドは小さいです)。

ただし、多くの場合、必要なポリモーフィックな動作は不変であり、コンパイル時に決定できます。その場合、Curiously Recurring Template Pattern (CRTP) を使用して静的ポリモーフィズムを実現できます。これは、プログラミングコードにおけるポリモーフィズムの模倣ですが、コンパイル時に解決されるため、実行時の仮想テーブル検索が不要になります。例:

テンプレート< class Derived > struct base { void interface () { // ... static_cast < Derived *> ( this ) -> implementation (); // ... } };  
 

     
    
         
         
         
    


構造体derived : base < derived > { void implementation () { // ... } };

ここで、基本クラステンプレートは、メンバー関数本体が宣言後までインスタンス化されないという事実を利用し、を使用して派生クラスのメンバーを自身のメンバー関数内で使用するため、static_castコンパイル時に多態的な特性を持つオブジェクト構成が生成されます。実際の使用例として、CRTP はBoost イテレータライブラリで使用されています。^[5]

同様の別の使用法として、「制限付きテンプレート拡張」と呼ばれることもある「バートン・ナックマントリック」があります。これは、共通機能を、契約としてではなく、コードの冗長性を最小限に抑えながら準拠した動作を強制するために必要なコンポーネントとして使用される基本クラスに配置できる方法です。

静的テーブル生成

静的テーブルの利点は、「コストのかかる」計算を単純な配列インデックス操作に置き換えることです (例については、ルックアップテーブルを参照してください)。C++ では、コンパイル時に静的テーブルを生成する方法が複数あります。次のリストは、再帰構造体と可変長テンプレートを使用して非常に単純なテーブルを作成する例を示しています。テーブルのサイズは 10 です。各値はインデックスの 2 乗です。

#include <iostream> #include <配列> 
 

constexpr int TABLE_SIZE = 10 ;    

/** 
* 再帰ヘルパー構造体の可変長テンプレート。
*/ 
template < int INDEX = 0 , int ... D > struct Helper : Helper < INDEX + 1 , D ..., INDEX * INDEX > { };     
           

/** 
* テーブルのサイズが TABLE_SIZE に達したときに再帰を終了するためのテンプレートの特殊化。
*/ 
template < int ... D > struct Helper < TABLE_SIZE , D ... > { static constexpr std :: array < int , TABLE_SIZE > table = { D ... }; }; 
   
          


constexpr std :: array < int , TABLE_SIZE > table = Helper <>:: table ;     

enum { FOUR = table [ 2 ] // コンパイル時に使用};  
     


int main () { for ( int i = 0 ; i < TABLE_SIZE ; i ++ ) { std :: cout << table [ i ] << std :: endl ; // 実行時使用} std :: cout << "FOUR: " << FOUR << std :: endl ; }

この背後にある考え方は、構造体ヘルパーが、テンプレートの特殊化が 10 要素のサイズで再帰を終了するまで、もう 1 つのテンプレート引数 (この例では INDEX * INDEX として計算) を持つ構造体から再帰的に継承するというものです。特殊化では、可変引数リストを配列の要素として単純に使用します。コンパイラは、次のようなコードを生成します (-Xclang -ast-print -fsyntax-only で呼び出された clang から取得)。

テンプレート< int INDEX = 0 , int ... D > struct Helper : Helper < INDEX + 1 , D ..., INDEX * INDEX > { };テンプレート<> struct Helper < 0 , <>> : Helper < 0 + 1 , 0 * 0 > { };テンプレート<> struct Helper < 1 , < 0 >> : Helper < 1 + 1 , 0 , 1 * 1 > { };テンプレート<> struct Helper < 2 , < 0 , 1 >> : Helper < 2 + 1 , 0 , 1 , 2 * 2 > { };テンプレート<> struct Helper < 3 , < 0 , 1 , 4 >> : Helper < 3 + 1 , 0 , 1 , 4 , 3 * 3 > { };テンプレート<> struct Helper < 4 , < 0 , 1 , 4 , 9 >> : Helper < 4 + 1 , 0 , 1 , 4 , 9 , 4 * 4 > { };テンプレート<> struct Helper < 5 , < 0 , 1 , 4 , 9 , 16 >> :ヘルパー< 5 + 1 , 0 ,                 

           

            

              

                

                  

             1、4、9、16、5 * 5 > { } ;テンプレート< > struct Helper < 6 、< 0、1、4、9、16、25 >> : Helper < 6 + 1、0、1、4、9、16、25、6 * 6 > { } ;テンプレート< > struct Helper < 7 、< 0、1、4、9、16、25、36 >> : Helper < 7 + 1、0、1、4、9、16、25、36、7 * 7 > { } ;テンプレート<> struct Helper < 8 , < 0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 >> : Helper < 8 + 1 , 0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 8 * 8 > { };テンプレート<> struct Helper < 9 , < 0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64 >> : Helper < 9 + 1 , 0 , 1 , 4 , 9 , 16 , 25       

                      

                        

                          

                     , 36 , 49 , 64 , 9 * 9 > { }; template <> struct Helper < 10 , < 0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64 , 81 >> { static constexpr std :: array < int , TABLE_SIZE > table = { 0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64 , 81 }; };

C++17 以降では、次のようにより読みやすく記述できます。

 
#include <iostream> #include <配列> 
 

constexpr int TABLE_SIZE = 10 ;    

constexpr std :: array < int , TABLE_SIZE > table = [] { // または: constexpr auto table std :: array < int , TABLE_SIZE > A = {}; for ( unsigned i = 0 ; i < TABLE_SIZE ; i ++ ) { A [ i ] = i * i ; } return A ; }();       
      
           
        
  
   


enum { FOUR = table [ 2 ] // コンパイル時に使用};  
     


int main () { for ( int i = 0 ; i < TABLE_SIZE ; i ++ ) { std :: cout << table [ i ] << std :: endl ; // 実行時使用} std :: cout << "FOUR: " << FOUR << std :: endl ; }

より洗練された例を示すために、次のリストのコードは、値計算のヘルパー (より複雑な計算に備えて)、テーブル固有のオフセット、およびテーブル値の型 (例: uint8_t、uint16_t、...) のテンプレート引数が追加されるように拡張されています。

                                                                
#include <iostream> #include <配列> 
 

constexpr int TABLE_SIZE = 20 ; constexpr int OFFSET = 12 ;    
    

/** 
* 単一のテーブルエントリを計算するテンプレート
*/ 
template < typename VALUETYPE 、VALUETYPE OFFSET 、VALUETYPE INDEX > struct ValueHelper { static constexpr VALUETYPE value = OFFSET + INDEX * INDEX ; };      
  
           


/** 
* 再帰ヘルパー構造体の可変長テンプレート。
*/ 
template < typename VALUETYPE , VALUETYPE OFFSET , int N = 0 , VALUETYPE ... D > struct Helper : Helper < VALUETYPE , OFFSET , N + 1 , D ..., ValueHelper < VALUETYPE , OFFSET , N >:: value > { };         
           

/** 
* テーブルのサイズが TABLE_SIZE に達したときに再帰を終了するためのテンプレートの特殊化。
*/ 
template < typename VALUETYPE , VALUETYPE OFFSET , VALUETYPE ... D > struct Helper < VALUETYPE , OFFSET , TABLE_SIZE , D ... > { static constexpr std :: array < VALUETYPE , TABLE_SIZE > table = { D ... }; };     
     
          


constexpr std :: array < uint16_t , TABLE_SIZE > table = Helper < uint16_t , OFFSET >:: table ;      

int main () { for ( int i = 0 ; i < TABLE_SIZE ; i ++ ) { std :: cout << table [ i ] << std :: endl ; } }

C++17 を使用すると次のように記述できます。

#include <iostream> #include <配列> 
 

constexpr int TABLE_SIZE = 20 ; constexpr int OFFSET = 12 ;    
    

template < typename VALUETYPE , int OFFSET > constexpr std :: array < VALUETYPE , TABLE_SIZE > table = [] { // または: constexpr auto table std :: array < VALUETYPE , TABLE_SIZE > A = {}; for ( unsigned i = 0 ; i < TABLE_SIZE ; i ++ ) { A [ i ] = OFFSET + i * i ; } return A ; }();   
       
      
           
          
  
   


int main () { for ( int i = 0 ; i < TABLE_SIZE ; i ++ ) { std :: cout << table < uint16_t , OFFSET > [ i ] << std :: endl ; } }

コンセプト

C++20標準はC++プログラマーにメタテンプレートプログラミングのための新しいツールであるコンセプトをもたらしました。^[6]

コンセプトを使用すると、プログラマーは型の要件を指定して、テンプレートのインスタンス化が可能になります。コンパイラーは、要件が最も高いコンセプトを持つテンプレートを探します。

以下は、テンプレートメタプログラミングを使用して解決された有名なFizz バズ問題の例です。

#include <boost/type_index.hpp> // 型のきれいな印刷用#include <iostream> #include <tuple> 
 
 

/** 
* 印刷する単語の型表現
*/ 
struct Fizz {}; struct Buzz {}; struct FizzBuzz {}; template < size_t _N > struct number { constexpr static size_t N = _N ; };  
  
  
           

/** 
* 特殊化の条件を定義するために使用される概念
*/ 
template < typename Any > concept has_N = requires { requires Any :: N - Any :: N == 0 ; }; template < typename A > concept fizz_c = has_N < A > && requires { requires A :: N % 3 == 0 ; }; template < typename A > concept buzz_c = has_N < A > && requires { requires A :: N % 5 == 0 ;}; template < typename A > concept fizzbuzz_c = fizz_c < A > && buzz_c < A > ;            
              
             
       

/** 
* `res` 構造体をコンセプト要件に合わせて特殊化することで、適切なインスタンス化が実行されます
*/ 
template < typename X > struct res ; template < fizzbuzz_c X > struct res < X > { using result = FizzBuzz ; }; template < fizz_c X > struct res < X > { using result = Fizz ; }; template < buzz_c X > struct res < X > { using result = Buzz ; }; template < has_N X > struct res < X > { using result = X ; };   
         
         
         
         

/** 
* 連結子の事前宣言
*/ 
template < size_t cnt , typename ... Args > struct concatenator ;     
 

/** 
* 次の型を連結する再帰的な方法
*/ 
template < size_t cnt , typename ... Args > struct concatenator < cnt , std :: tuple < Args ... >> { using type = typename concatenator < cnt - 1 , std :: tuple < typename res < number < cnt > >:: result , Args ... >>:: type ;};     
   
              

/** 
* 基本ケース
*/ 
template < typename ... Args > struct concatenator < 0 , std :: tuple < Args ... >> { using type = std :: tuple < Args ... > ;};          

/** 
* 最終結果ゲッター
*/ 
template < size_t Amount > using fizz_buzz_full_template = typename concatenator < Amount - 1 , std :: tuple < typename res < number < Amount >>:: result >>:: type ; 
        

int main () { // boost で結果を出力するのでわかりやすいstd :: cout << boost :: typeindex :: type_id < fizz_buzz_full_template < 100 >> (). pretty_name () << std :: endl ; /*結果: 	std::tuple<number<1ul>, number<2ul>, Fizz, number<4ul>, Buzz, Fizz, number<7ul>, number<8ul>, Fizz, Buzz, number<11ul>, Fizz, number<13ul>, number<14ul>, FizzBuzz, number<16ul>, number<17ul>, Fizz, number<19ul>, Buzz, Fizz, number<22ul>, number<23ul>, Fizz, Buzz, number<26ul>, Fizz, number<28ul>, number<29ul>, FizzBuzz, number<31ul>, number<32ul>, Fizz, number<34ul>, Buzz, Fizz, number<37ul>, number<38ul>, Fizz, Buzz, number<41ul>, Fizz, number<43ul>, number<44ul>, FizzBuzz、番号<46ul>、番号<47ul>、Fizz、番号<49ul>、Buzz、Fizz、番号<52ul>、番号<53ul>、Fizz、Buzz、番号<56ul>、Fizz、番号<58ul>、番号<59ul>、FizzBuzz、番号<61ul>、番号<62ul>、Fizz、番号<64ul>、Buzz、Fizz、番号<67ul>、番号<68ul>、Fizz、Buzz、番号<71ul>、Fizz、番号<73ul>、番号<74ul>、FizzBuzz、番号<76ul>、番号<77ul>、Fizz、番号<79ul>、Buzz、Fizz、番号<82ul>、番号<83ul>、Fizz、Buzz、番号<86ul>、Fizz、番号<88ul>、番号<89ul>、FizzBuzz、数値<91ul>、数値<92ul>、フィズ、数値<94ul>、バズ、フィズ、数値<97ul>、数値<98ul>、フィズ、バズ> */ }

テンプレートメタプログラミングの利点と欠点

テンプレートメタプログラミングを多用すると、コンパイル時間と実行時間のトレードオフが明らかになります。

テンプレートメタプログラミングにより、プログラマーはアーキテクチャに集中し、クライアントコードに必要な実装の生成をコンパイラーに委任することができます。したがって、テンプレートメタプログラミングは真に汎用的なコードを実現し、コードの最小化と保守性の向上を促進します^{[引用が必要]}。
C++11より前のバージョンでは、テンプレートメタプログラミングの構文と慣用句は従来のC++プログラミングに比べて難解で、テンプレートメタプログラムは非常に理解しにくいものでした。^[7]^[8]しかし、C++11以降では、値計算メタプログラミングの構文は「通常の」C++にますます似てきており、読みやすさの低下はますます少なくなっています。

参照

参考文献

^ スコット・マイヤーズ (2005 年 5 月 12 日)。効果的な C++: プログラムとデザインを改善する 55 の具体的な方法。ピアソンエデュケーション。ISBN 978-0-13-270206-5。
^ ウィキブックスのTMPの歴史を参照
^ フェルドハイゼン、トッド L. (2003)。「C++ テンプレートはチューリング完成です」。CiteSeerX 10.1.1.14.3670。
^ 「Constexpr - C++11 の一般化された定数式 - Cprogramming.com」。www.cprogramming.com。
^ 「イテレータファサード - 1.79.0」。
^ 「制約と概念 (C++20 以降) - cppreference.com」。en.cppreference.com。
^ Czarnecki, K.; O'Donnell, J.; Striegnitz, J.; Taha, Walid Mohamed (2004). 「DSL 実装 (metaocaml、template haskell、C++)」(PDF)。ウォータールー大学、グラスゴー大学、Julich 研究センター、ライス大学。C ++ テンプレートメタプログラミングには、コンパイラの制限による移植性の問題 (ただし、ここ数年で大幅に改善されています)、テンプレートのインスタンス化中のデバッグサポートや IO の欠如、コンパイル時間が長い、エラーが長くて理解しにくい、コードの読みにくさ、エラーレポートの質の悪さなど、さまざまな制限があります。
^ Sheard, Tim; Jones, Simon Peyton (2002). 「Haskell のテンプレートメタプログラミング」(PDF) . ACM 1-58113-415-0/01/0009. Robinson の刺激的な論文では、C++ テンプレートが C++ 言語設計の大きな、しかし偶然の成功であるとしています。テンプレートメタプログラミングの極めて奇抜な性質にもかかわらず、テンプレートは言語設計者の最も大胆な夢をはるかに超える魅力的な方法で使用されています。テンプレートが関数型プログラムであるという事実を考えると、おそらく驚くべきことですが、関数型プログラマーは C++ の成功をなかなか活用していません。

アイゼネッカー、ウルリッヒ W. (2000)。『ジェネレーティブプログラミング：方法、ツール、アプリケーション』。アディソン・ウェズリー。ISBN 0-201-30977-7。
Alexandrescu, Andrei (2003)。Modern C++ Design: Generic Programming and Design Patterns Applied。Addison - Wesley。ISBN 3-8266-1347-3。
Abrahams, David ; Gurtovoy, Aleksey (2005 年 1 月)。C ++ テンプレートメタプログラミング: Boost 以降の概念、ツール、テクニック。Addison- Wesley。ISBN 0-321-22725-5。
ヴァンデフォールデ、デイビッド。ジョスティス、ニコライ M. (2003)。C++ テンプレート: 完全ガイド。アディソン・ウェスリー。ISBN 0-201-73484-2。
クラベル、マヌエル (2000-10-16)。書き換えロジックのリフレクション: メタ論理的基礎とメタプログラミングアプリケーション。ケンブリッジ大学出版局。ISBN 1-57586-238-7。

外部リンク

「Boost メタプログラミングライブラリ (Boost MPL)」。
「スピリットライブラリー」。(テンプレートメタプログラミングを使用して構築)
「Boost Lambda ライブラリ」。(STLアルゴリズムを簡単に使用できます)
Veldhuizen, Todd (1995 年 5 月)。「C++ テンプレートメタプログラムの使用」。C ++レポート7 (4): 36–43。2009 年 3 月 4 日のオリジナルからのアーカイブ。
「テンプレートHaskell」。(Haskell での型安全なメタプログラミング)
Bright、Walter。「テンプレートの再考」。( Dプログラミング言語におけるテンプレートメタプログラミング)
コスキネン、ヨハネス。「C++ のメタプログラミング」(PDF)。
Attardi, Giuseppe; Cisternino, Antonio. 「テンプレートメタプログラミングによるリフレクションサポート」(PDF)。
Burton, Michael C.; Griswold, William G.; McCulloch, Andrew D.; Huber, Gary A. (2002). 「静的データ構造」. CiteSeerX 10.1.1.14.5881 .
Amjad, Zeeshan (2007 年 8 月 13 日)。「テンプレートメタプログラミングと数論」。
Amjad, Zeeshan (2007 年 8 月 24 日)。「テンプレートメタプログラミングと数論: パート 2」。
「C++ での LISP スタイルプログラミング用ライブラリ」。

[Meyers2005-1] スコット・マイヤーズ (2005 年 5 月 12 日)。効果的な C++: プログラムとデザインを改善する 55 の具体的な方法。ピアソンエデュケーション。ISBN 978-0-13-270206-5。

[2] ウィキブックスのTMPの歴史を参照

[Veldhuizen2003-3] フェルドハイゼン、トッド L. (2003)。「C++ テンプレートはチューリング完成です」。CiteSeerX 10.1.1.14.3670。

[4] 「Constexpr - C++11 の一般化された定数式 - Cprogramming.com」。www.cprogramming.com。

[5] 「イテレータファサード - 1.79.0」。

[6] 「制約と概念 (C++20 以降) - cppreference.com」。en.cppreference.com。

[7] Czarnecki, K.; O'Donnell, J.; Striegnitz, J.; Taha, Walid Mohamed (2004). 「DSL 実装 (metaocaml、template haskell、C++)」(PDF)。ウォータールー大学、グラスゴー大学、Julich 研究センター、ライス大学。C ++ テンプレートメタプログラミングには、コンパイラの制限による移植性の問題 (ただし、ここ数年で大幅に改善されています)、テンプレートのインスタンス化中のデバッグサポートや IO の欠如、コンパイル時間が長い、エラーが長くて理解しにくい、コードの読みにくさ、エラーレポートの質の悪さなど、さまざまな制限があります。

[8] Sheard, Tim; Jones, Simon Peyton (2002). 「Haskell のテンプレートメタプログラミング」(PDF) . ACM 1-58113-415-0/01/0009. Robinson の刺激的な論文では、C++ テンプレートが C++ 言語設計の大きな、しかし偶然の成功であるとしています。テンプレートメタプログラミングの極めて奇抜な性質にもかかわらず、テンプレートは言語設計者の最も大胆な夢をはるかに超える魅力的な方法で使用されています。テンプレートが関数型プログラムであるという事実を考えると、おそらく驚くべきことですが、関数型プログラマーは C++ の成功をなかなか活用していません。