C ++ 11またはT &&の「ユニバーサル」参照は、必ずしも「右辺値参照」を意味するわけではありません

C ++プログラミング言語の専門家であり、多くの有名な本の著者であるScott Meyersは、C ++ 11で右辺値リンクを使用する詳細を説明する記事を発行しました。

このトピックはまだHabréで取り上げられていませんが、この記事はコミュニティにとって興味深いものになると思います。

元の記事： 「C ++ 11のユニバーサルリファレンス— Scott Meyers」

C ++ 11のユニバーサルリンク

T &&は常に「Rvalue Reference」を意味するわけではありません

投稿者： Scott Meyers



おそらく、C ++ 11で最も重要な革新は右辺値リンクです。 これらは、「転送のセマンティクス（英語の移動セマンティクス）」および「完全な転送」が構築される基盤として機能します。 （ Thomas Beckerのレビューで、これらのメカニズムの基本に慣れることができます ）。



構文的に右辺値リンクは、「通常の」リンク（現在左辺値リンクと呼ばれる）と同じ方法で宣言されますが、1つではなく2つのアンパサンドを使用します。 したがって、この関数は、rvalue-reference-to-Widget型のパラメーターを受け入れます。

void f(Widget&& param);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

右辺値参照が&&を使用して宣言されていることを考えると、型宣言内の&&の存在が右辺値参照を示していると仮定するのは合理的です。 しかし、これはそうではありません：

 Widget&& var1 = someWidget; //  “&&”  rvalue  auto&& var2 = var1; //  “&&”   rvalue  template<typename T> void f(std::vector<T>&& param); //  “&&”  rvalue  template<typename T> void f(T&& param); //  “&&”   rvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この記事では、型宣言の2つの「&&」の意味を説明し、それらを互いに区別する方法を説明し、使用する「&&」値を明確に決定できる新しい用語を紹介します。 型宣言に「&&」が表示されているときに「右辺値リンク」について考えると、大量のC ++ 11コードを誤解するため、異なる値を強調表示することが重要です。



ポイントは、型宣言の&&は右辺値リンクを意味することですが、右辺値リンクまたは左辺値リンクのいずれかを意味する場合もあります。 したがって、場合によっては、ソースコードの「&&」の値が「＆」、つまり 構文的には右辺値参照（「&&」）の形式ですが、実際には左辺値参照（「＆」）になります。



リンクは、左辺値リンクまたは右辺値リンクよりも柔軟な概念です。 したがって、右辺値リンクは右辺値にのみ関連付けることができ、左辺値リンクは左辺値にバインドできることに加えて、限られた条件下で右辺値に関連付けることができます（左辺値リンクと右辺値のリンクの制限は、そのようなリンクが許可されるのは、左辺値リンクは、定数、つまりconst T＆への参照として宣言されます。左辺値リンクまたは右辺値リンクのいずれかである&&で宣言されたリンクは、あらゆるものに接続できます。 このような非常に柔軟なリンクは、その名前に値します。 私はそれらを「ユニバーサル」リンクと呼びました。



「&&」が普遍的な参照を意味する場合（つまり、ソースコードの「&&」が実際に「＆」を意味する場合）の詳細は非常に複雑であるため、説明を先送りします。 さて、次のルールに焦点を当てましょう。これは、毎日プログラミングするときに覚えておくべきことです。



推定される型 Tに対して型T &&で変数またはパラメーターが宣言されている場合、そのような変数またはパラメーターは汎用参照です。



型推論の要件により、普遍的な参照がある状況の範囲が制限されます。 ほとんどすべての汎用参照は、関数テンプレートのパラメーターです。 また、自動宣言された変数の型推論規則はテンプレートの場合と基本的に同じであるため、自動宣言されたユニバーサル参照が可能です。 これらは本番コードではあまり見られませんが、テンプレートの冗長な例ではないため、この記事ではその一部を紹介します。 この記事の「スモールディテール」セクションでは、typedefおよびdecltypeの使用に関連するユニバーサルリンクの可能性を示しますが、「スモールディテール」に到達するまで、ユニバーサルリンクは関数テンプレートと自動リンクのみを参照すると想定します。宣言された変数。



T &&ユニバーサルリンク宣言フォームは、見かけよりも重要な要件ですが、後でこの問題に戻ります。 それまでの間、この要件を念頭に置いてください。



すべてのリンクと同様に、ユニバーサルリンクは初期化する必要があり、それが左辺値リンクと右辺値リンクのどちらであるかを決定するのはユニバーサルリンクイニシャライザーです。

• ユニバーサル参照を初期化する式が左辺値である場合、ユニバーサル参照は左辺値参照になります。
• ユニバーサル参照を初期化する式が右辺値である場合、ユニバーサル参照は右辺値参照になります。

この情報は、左辺値と右辺値を区別できる場合にのみ役立ちます。 これらの用語を正確に定義することは困難です（C ++ 11標準では、式が左辺値であるか右辺値であるかは一般的に定義されています）が、実際には以下で十分です。

• 式のアドレスを取得できる場合、この式は左辺値です。
• 式の型が左辺値参照（つまり、T＆またはconst T＆など）である場合、この式は左辺値です。
• それ以外の場合、式は右辺値です。 概念的に（そして通常、実際）、右辺値は、関数から返されたオブジェクトや暗黙的な型変換によって作成されたオブジェクトなどの一時オブジェクトに対応します。 ほとんどのリテラル（10や5.3など）も右辺値です。

記事の冒頭のコードをもう一度見てみましょう。

 Widget&& var1 = someWidget; auto&& var2 = var1;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

アドレスvar1を取得できます。それぞれvar1は左辺値です。 var2をauto &&として宣言すると、var2は汎用参照になり、var1（lvalue）によって初期化されるため、var2は左辺値参照になります。



ソースコードを不注意に読むと、var2が右辺値参照であると思われる可能性があります。 もちろん、広告の「&&」はこの考えにつながります。 ただし、var2は左辺値によって初期化される汎用参照であるため、左辺値参照です。 var2が次のように宣言されているようです。

 Widget& var2 = var1;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

上記のように、式がリンクの左辺値型である場合、それは左辺値です。 この例を考えてみましょう：

 std::vector<int> v; ... auto&& val = v[0]; // val  lvalue  (. )
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

valは汎用参照であり、初期化されたv [0]です。つまり、 std :: vector <int> :: operator []を呼び出した結果。 この関数は、ベクトル要素への左辺値参照を返します（配列を超えることは無視しますが、これは未定義の動作につながります）。



すべての左辺値参照は左辺値であり、この左辺値はvalの初期化に使用されるため、val型宣言は右辺値参照のように見えますが、valは左辺値参照になります。



ユニバーサルリンクは、関数テンプレートパラメーターで最も一般的であることに注意しました。 この記事の最初からテンプレートを再度検討してください。

 template<typename T> void f(T&& param); // “&&”   rvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

このような呼び出しfでは、

 f(10); // 10  rvalue
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

paramはリテラル10で初期化されます。これは、アドレスを取得できないという理由で右辺値です。 これは、fの呼び出しで、汎用パラメーター参照が右辺値に初期化され、したがって右辺値参照になることを意味します。具体的には、int &&です。



一方、fが次のように呼び出された場合：

 int x = 10; f(x); // x  lvalue
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

paramは変数xに初期化されます。これは、アドレスを取得できるという理由で左辺値です。 つまり、このfの呼び出しでは、ユニバーサルparam参照が左辺値に初期化され、したがってparamは正確には-int＆への左辺値参照になります。



fの宣言の横にあるコメントは明確になりました。param型が左辺値参照であるか右辺値参照であるかは、呼び出し中にfに渡されたものに依存します。 paramは左辺値参照になることもあれば、右辺値参照になることもあります。 つまり、paramは確かに普遍的な参照です。



&&は、型推論が行われる場合にのみユニバーサル参照を示すことに注意してください。 型の推論がない場合、普遍的な参照はありません。 そのような場合、型宣言の「&&」は常に右辺値参照を意味します。 したがって：

 template<typename T> void f(T&& param); //    ⇒  ; && ≡   template<typename T> class Widget { ... Widget(Widget&& rhs); //     ⇒   ; ... // && ≡ rvalue  }; template<typename T1> class Gadget { ... template<typename T2> Gadget(T2&& rhs); //    ⇒  ; && ≡   }; void f(Widget&& param); //     ⇒   ; // && ≡ rvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これらの例には驚くべきことは何もありません。 いずれにせよ、T &&（Tはテンプレートパラメーター）が表示される場合、型推論が存在するため、ユニバーサルリンクを見ています。 また、特定のタイプ名（たとえば、Widget &&）の後に「&&」が表示されている場合は、右辺値リンクを確認します。



リンクをユニバーサルにするためには、リンク宣言フォームは「T &&」である必要があると述べました。 これは重要なニュアンスです。 この記事の冒頭の宣言をもう一度見てください。

 template<typename T> void f(std::vector<T>&& param); // “&&”  rvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここには型推論と「&&」の両方があります-説明されている関数パラメーターですが、パラメーターの宣言形式は「T &&」ではなく「std :: vector <T> &&」です。 その結果、パラメーターは通常の右辺値参照であり、汎用参照ではありません。 ユニバーサルリンク宣言は、「T &&」の形式でのみ使用できます。 const修飾子を追加しても、「&&」を普遍的な参照として解釈しないためには十分です。

 template<typename T> void f(const T&& param); // “&&”  rvalue 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「T &&」は、ユニバーサルリンクを宣言するために必要な形式です。 これは、テンプレートパラメータに名前Tを使用する必要があるという意味ではありません。

 template<typename MyTemplateParamType> void f(MyTemplateParamType&& param); // “&&”   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

テンプレート関数宣言でT &&を確認できる場合があります。Tはテンプレートパラメーターですが、型推論はまだありません。 std :: vectorのpush_back関数を検討してください（対象のバージョンのみが表示されます

 std::vector::push_back): template <class T, class Allocator = allocator<T> > class vector { public: ... void push_back(T&& x); //     ⇒   ; ... // && ≡ rvalue  };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ここで、Tはテンプレートパラメーターであり、push_backはT &&を受け入れます。 ただし、パラメーターは普遍的な参照ではありません！ これはどのようにできますか？



push_backがクラス外でどのように宣言されるかを見ると、答えが明らかになります。 コードを乱雑にしないために、Allocatorパラメーターが欠落しているふりをします。 これを考えると、以下はこのバージョンの宣言です

std ::ベクトル:: push_back：

 template <class T> void vector<T>::push_back(T&& x);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

push_backは、std :: vector <T>クラスなしでは存在できません。 しかし、クラスstd :: vector <T>がある場合、Tが何であるかは既にわかっているため、この型を推測する必要はありません。



例を見てみましょう。 書いたら

 Widget makeWidget(); //    Widget std::vector<Widget> vw; ... Widget w; vw.push_back(makeWidget()); //  Widget    vw
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

push_packを使用すると、std :: vector <Widget>クラスに対してこの関数をインスタンス化するようコンパイラーに指示します。 クラス外での彼女の宣言は次のようになります。

 void std::vector<Widget>::push_back(Widget&& x);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

分かりますか？ クラスがstd :: vector <Widget>であることがわかるとすぐに、push_backパラメーターのタイプが完全に定義されます。 型推論は実行されません。

これを、次のように宣言されているemplace_back std :: vectorメソッドと比較します。

 template <class T, class Allocator = allocator<T> > class vector { public: ... template <class... Args> void emplace_back(Args&&... args); //    ⇒  ; ... // && ≡   };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

emplace_backが可変数の引数を受け入れるという事実に注意を払わないでください（Argsおよびargs宣言で示されているように）。 ここで重要なのは、各引数の型を推測する必要があるということです。 Args関数のテンプレートパラメーターは、クラスTのテンプレートパラメーターとは無関係です。そのため、クラスが完全にわかっている場合（std :: vector <Widget>など）でも、emplace_back引数のタイプについては何も言いません。 std :: vector <Widget>のクラス外のemplace_back宣言は、これを明確に示しています（Allocatorパラメーターの存在は無視し続けています）。

 template<class... Args> void std::vector<Widget>::emplace_back(Args&&... args);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

明らかに、クラスがstd :: vector <Widget>であることを知っていても、emplace_backに渡される型を推測する必要はありません。 その結果、std :: vector :: emplace_backパラメーターは、見たとおり右辺値リンクであるstd :: vector :: push_backバージョンパラメーターとは異なり、ユニバーサルリンクです。



式が左辺値であるか右辺値であるかは、その型に依存しないことに注意してください。 タイプintを検討してください。 型intの左辺値（たとえば、intによって宣言された変数）と、型intの右辺値（たとえば、リテラル、たとえば10）があります。 これは、ウィジェットのようなカスタムタイプに当てはまります。 Widgetオブジェクトは、左辺値（たとえば、Widget変数）または右辺値（たとえば、ファクトリ関数が作成されたWidgetオブジェクトを返した）です。 式のタイプは、それが左辺値か右辺値かを教えません。

 Widget makeWidget(); //    Widget Widget&& var1 = makeWidget(); // var1  lvalue,   // var1 –  rvalue  ( Widget) Widget var2 = static_cast< Widget&& >(var1); // cast   rvalue,  //   -  rvalue  ( Widget)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

左辺値（たとえば、var1）を右辺値に変換する一般的な方法は、std :: moveを使用することです。したがって、var2は次のように定義できます。

 Widget var2 = std::move(var1); //   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

もともと、式の型が右辺値参照（Widget &&）であることを明示するためだけにstatic_castを使用したコードを引用しました。



型右辺値参照の名前付き変数とパラメーターは左辺値です。 （アドレスを取得できます。）もう一度、ウィジェットとガジェットのテンプレートを検討してください。

 template<typename T> class Widget { ... Widget(Widget&& rhs); //  rhs - rvalue , ... //  rhs  lvalue }; template<typename T1> class Gadget { ... template <typename T2> Gadget(T2&& rhs);// rhs      ... //     rvalue   }; // lvalue ,  rhs  lvalue
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Widgetコンストラクターでは、rhsは右辺値参照であるため、右辺値に関連付けられている（つまり右辺値が渡された）ことがわかりますが、rhs自体は左辺値であるため、それを利用するには右辺値に変換する必要がありますそのrhsは右辺値に関連しています。 原則として、転送ソースとしてrhsを使用する必要があるため、std :: moveを使用して左辺値を右辺値に変換します。 同様に、ガジェットコンストラクターのrhsは汎用参照であるため、左辺値または右辺値に関連付けることができますが、いずれにしても、rhs自体は左辺値です。 それが右辺値に関連しており、これを利用したい場合は、rhsを右辺値に変換する必要があります。 ただし、左辺値に関連付けられている場合、右辺値として扱いたくないことは確かです。 ユニバーサルリンクが関連付けられているものへのこの依存性が、std :: forward：を使用して、ユニバーサルリンクを取得し、右辺値式に関連付けられている場合にのみ右辺値に変換する理由です。 関数の名前（「forward」）は、引数参照のタイプ（左辺値または右辺値）を常に維持したまま、別の関数に転送するという期待を裏付けています。



ただし、std :: moveおよびstd :: forwardは、この記事の主題ではありません。 この記事では、型宣言の&&が右辺値リンクを記述する場合と記述しない場合があるという事実について説明しています。 気が散らないように、std :: moveおよびstd :: forwardの詳細な説明については、「追加情報」セクションのリンクを参照してください。

細部

ポイントは、C ++ 11の一部の構成体がリンクへのリンクを生成し、C ++ではリンクへのリンクが許可されないことです。 ソースコードにリンクへのリンクが明示的に含まれている場合、コードは正しくありません。

 Widget w1; ... Widget& & w2 = w1; // !     “  ”
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、コンパイル中に発生する型の操作の結果としてリンクへのリンクが発生する場合があり、そのような場合、このコードを拒否すると問題が発生します。 これは、C ++の元の標準、つまりC ++ 98 / C ++ 03の経験から知っています。



汎用参照であるテンプレートパラメーターの型推論中に、同じ型の左辺値と右辺値がいくつかの異なる型に出力されます。 特に、タイプTの左辺値はタイプT＆（つまり、Tへの左辺値参照）として出力され、タイプTの右辺値は単純に型Tとして出力されます（左辺値は左辺値参照として出力され、右辺値参照として出力されないことに注意してください！）右辺値と左辺値を持つ汎用参照を受け入れるテンプレート関数を呼び出すとどうなるかを考えてみましょう。

 template<typename T> void f(T&& param); ... int x; ... f(10); //  f  rvalue f(x); //  f  lvalue
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

rvalue 10 Tでfを呼び出すと、intとして出力され、fのインスタンス化は次のようになります。

 void f(int&& param); // f   rvalue
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これはいいです。 ただし、左辺値xを持つfの呼び出しでは、Tはint＆として出力され、fインスタンスにはリンクへのリンクが含まれます。

 void f(int& && param); //   f  lvalue
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

リンクへのリンクのため、このインスタンスコードは一見正しくないように見えますが、ソースコード「f（x）」は非常に合理的です。 このコードを拒否しないように、C ++は、リンクへのリンクがテンプレートのインスタンス化などのコンテキストで表示されるときに「リンクの折りたたみ」を実行します。



2種類のリンク（左辺値リンクと右辺値リンク）があるため、左辺リンクから左辺値リンク、左辺値リンクから右辺値リンク、右辺値リンクから左辺値リンク、右辺値リンクから右辺値リンクの4つの可能な組み合わせがあります。 リンクの折りたたみには2つのルールのみがあります。

• 右辺値リンクへの右辺値リンクは右辺値リンクになります（「折りたたむ」）。
• リンクへの他のすべてのリンク（つまり、左辺値リンクを含むすべての組み合わせ）は、左辺値リンクにまとめられます。

これらの規則を適用して、左辺値でfをインスタンス化すると、次の正しいコードが得られます。

 void f(int& param); //  f  lvalue   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これにより、（型の推論とリンクの折りたたみの後の）ユニバーサルリンクを左辺値リンクに変換できる正確なメカニズムが提供されます。 実際、ユニバーサルリンクは、リンクフォールディングのコンテキストにおける単なる右辺値リンクです。



リンクである変数の型が推定される特別な状況。 この場合、リンクを示すタイプの部分は無視されます。 たとえば、

 int x; ... int&& r1 = 10; //  r1 - int&& int& r2 = x; //  r2 - int&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

テンプレートfを呼び出すときのr1とr2の両方の型はintと見なされます。 リンクを削除するこの動作は、ジェネリック型の型推論規則に依存せず、左辺値は型T＆として出力され、右辺値は型Tとして出力されるため、これらの呼び出しでは、

 f(r1); f(r2);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

r1とr2の両方に対して推定される型はint＆です。 なんで？ 最初に、タイプr1およびr2の参照部分は破棄され（両方のケースでintになります）、それが左辺値であるため、両方がfの呼び出しのユニバーサル参照パラメーターの型推論中にint＆として扱われます。



前述のように、リンクの折りたたみは「テンプレートのインスタンス化などのコンテキスト」で発生します。 2番目のそのようなコンテキストは、「自動」変数の定義です。 タイプTの左辺値はタイプT＆を持ち、タイプTの右辺値はタイプT＆を持つとして出力されるため、ユニバーサル変数である自動変数のタイプ推論は、ユニバーサルリファレンスである関数テンプレートパラメーターのタイプ推論と本質的に同じです。 記事の最初からもう一度例を考えてみましょう。

 Widget&& var1 = someWidget; // var1   Widget&& (auto  ) auto&& var2 = var1; // var2   Widget& (. )
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

タイプvar1はWidget &&ですが、var2が初期化されるときのタイプの推論中にその「参照部分」は無視されます。 これはウィジェットの一種と見なされます。 これはユニバーサル参照（var2）の初期化に使用される左辺値であるため、推定される型はWidget＆になります。 var2定義でautoの代わりにWidget＆を代入すると、次の無効なコードが取得されます。

 Widget& && var2 = var1; //      
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

リンクを折りたたんだ後になります

 Widget& var2 = var1; // var2   Widget&
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

リンクの折りたたみの3番目のコンテキストは、typedefの形成と使用です。 このクラステンプレートを考える

 template<typename T> class Widget { typedef T& LvalueRefType; ... };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして、このテンプレートのそのような使用、

 Widget<int&> w;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

インスタンス化されたクラスには、次の（無効な）typedefが含まれます。

 typedef int& & LvalueRefType;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

折りたたみリンクは、次の有効なコードにつながります。

 typedef int& LvalueRefType;
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

たとえば、このtypedefを、それへの参照を使用してコンテキストで使用すると、

 void f(Widget<int&>::LvalueRefType&& param);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

typedefが展開された後、次の無効なコードが生成されます、

 void f(int& && param);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ただし、リンクを折り畳むと切り捨てられ、fの最終宣言は次のようになります。

 void f(int& param);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

リンクの折りたたみが適用される最後のコンテキストは、decltypeを使用することです。 テンプレートとautoの場合と同様に、decltypeはTまたはT＆のいずれかを与える式の型推論を実行し、decltypeはC ++ 11リンク折りたたみ規則を適用します。



, , decltype , auto . ( « » ), , decltype T (.. ), auto- T&. , decltype decltype ; ( ) . :

 Widget w1, w2; auto&& v1 = w1; // v1   , //  lvalue,  v1 //  lvalue   w1. decltype(w1)&& v2 = w2; // v2   ,  decltype(w1)  Widget, //   v2  rvalue . // w2  lvalue,    // rvalue  lvalue,      .
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

おわりに

“&&” rvalue , – , lvalue rvalue . T&& T.



– ( rvalue , ) lvalue , rvalue . , . , auto-, typedef decltype.

謝辞

Cassio Neri, Michal Mocny, Howard Hinnant, Andrei Alexandrescu, Stephan T. Lavavej, Roger Orr, Chris Oldwood, Jonathan Wakely Anthony Williams. , .

追加情報

C++11, Wikipedia.



Overview of the New C++ (C++11), Scott Meyers, Artima Press, last updated January 2012.



C++ Rvalue References Explained, Thomas Becker, last updated September 2011.



decltype, Wikipedia.



“A Note About decltype,” Andrew Koenig, Dr. Dobb's, 27 July 2011.