非const参照が一時オブジェクトにバインドできないのはなぜですか？

一時オブジェクトへの非const参照の取得が許可されないのはなぜgetx()ですか、どの関数が返しますか？明らかに、これはC ++標準では禁止されていますが、標準への参照ではなく、そのような制限の目的に興味があります。

struct X
{
    X& ref() { return *this; }
};

X getx() { return X();}

void g(X & x) {}    

int f()
{
    const X& x = getx(); // OK
    X& x = getx(); // error
    X& x = getx().ref(); // OK
    g(getx()); //error
    g(getx().ref()); //OK
    return 0;
}

1. C ++標準ではオブジェクトへの常時参照が禁止されていないため、オブジェクトの存続期間が原因ではないことは明らかです。
2. 非定数関数の呼び出しが許可されているため、上記のサンプルでは一時オブジェクトが定数ではないことは明らかです。たとえばref()、一時オブジェクトを変更できます。
3. さらにref()、コンパイラーをだますことができ、この一時オブジェクトへのリンクを取得できます。これにより問題が解決されます。

加えて：

彼らは、「const参照に一時オブジェクトを割り当てると、このオブジェクトの寿命が延びる」と述べ、「非const参照については何も言われていない」と述べています。私の追加の質問。次の割り当ては一時オブジェクトの寿命を延ばしますか？

X& x = getx().ref(); // OK

右辺値参照に関するこのVisual C ++ブログ記事から：

... C ++は誤って一時を変更することを望まないが、変更可能な右辺値で非constメンバー関数を直接呼び出すことは明示的であるため、許可される...

基本的に、一時オブジェクトであり、すぐに死ぬという理由で一時オブジェクトを変更しようとするべきではありません。非constメソッドの呼び出しが許可される理由は、まあ、あなたが何をしているかを理解していて、それについて明示的である（たとえばreinterpret_castを使用する）限り、いくつかの「ばかげた」ことをするのは大歓迎です。ただし、テンポラリを非const参照にバインドすると、オブジェクトの操作が消えるようにするために、それを「永久に」渡し続けることができます。これは、途中でこれを完全に忘れてしまったためです。

もし私があなただったら、私の機能のデザインを考え直します。g（）が参照を受け入れるのはなぜですか？パラメータを変更しますか？いいえの場合、それをconst参照にします。そうであれば、なぜそれに一時を渡そうとしますか、それが変更中の一時であることを気にしませんか？とにかくgetx（）が一時的に戻るのはなぜですか？実際のシナリオと達成しようとしていることを私たちと共有すると、それを行う方法についていくつかの良い提案が得られる場合があります。

言語に逆らってコンパイラをだまして問題を解決することはめったにありません-通常それは問題を引き起こします。

2）目的を明確に述べた：一時的なものを変更することはできません。なぜなら、それが意味をなさないからです（C ++ 0x右辺値参照を無視する）。「では、なぜ非constメンバーを呼び出すことを許可されるのですか？」という質問。良い質問ですが、上で述べた質問よりも良い答えはありません。

3）まあ、私がxについてX& x = getx().ref();声明の最後で死ぬのが正しいなら、問題は明白です。

とにかく、あなたの質問とコメントに基づいて、私はこれらの余分な答えがあなたを満足させるとは思いません。これが最後の試み/要約です。C++委員会は、一時を変更することは意味がないと判断したため、非const参照へのバインドを許可しませんでした。コンパイラの実装か、歴史的な問題も関係していたのかもしれませんが、わかりません。その後、いくつかの特定のケースが発生し、すべてのオッズに対して、非constメソッドを呼び出すことで直接変更できるようにすることが決定されました。ただし、これは例外です。通常、一時を変更することはできません。はい、C ++はしばしば奇妙です。

コードでgetx()は、一時的なオブジェクト、いわゆる「右辺値」を返します。右辺値をオブジェクト（別名：変数）にコピーするか、それらをconst参照にバインドできます（これにより、参照の寿命が尽きるまで寿命が延長されます）。右辺値を非const参照にバインドすることはできません。

これは、ユーザーが式の最後で終了するオブジェクトを誤って変更しないようにするための、意図的な設計の決定でした。

g(getx()); // g() would modify an object without anyone being able to observe

これを行う場合は、最初にローカルコピーまたはオブジェクトのコピーを作成するか、それをconst参照にバインドする必要があります。

X x1 = getx();
const X& x2 = getx(); // extend lifetime of temporary to lifetime of const reference

g(x1); // fine
g(x2); // can't bind a const reference to a non-const reference

次のC ++標準には右辺値参照が含まれることに注意してください。したがって、参照として知っているものは、「左辺値参照」と呼ばれるようになっています。右辺値を右辺値参照にバインドすることが許可され、「rvalue-ness」で関数をオーバーロードできます。

void g(X&);   // #1, takes an ordinary (lvalue) reference
void g(X&&);  // #2, takes an rvalue reference

X x; 
g(x);      // calls #1
g(getx()); // calls #2
g(X());    // calls #2, too

右辺値参照の背後にある考え方は、これらのオブジェクトはとにかく死ぬので、その知識を利用して、「移動セマンティクス」と呼ばれるもの、特定の種類の最適化を実装できるということです。

class X {
  X(X&& rhs)
    : pimpl( rhs.pimpl ) // steal rhs' data...
  {
    rhs.pimpl = NULL; // ...and leave it empty, but deconstructible
  }

  data* pimpl; // you would use a smart ptr, of course
};


X x(getx()); // x will steal the rvalue's data, leaving the temporary object empty

表示されているのは、演算子の連鎖が許可されていることです。

 X& x = getx().ref(); // OK

式は 'getx（）。ref（）;'です。そして、これは「x」に割り当てる前に完了するまで実行されます。

getx（）は参照を返さず、完全に形成されたオブジェクトをローカルコンテキストに返すことに注意してください。オブジェクトは一時的ですがconst ではないため、他のメソッドを呼び出して値を計算したり、他の副作用を発生させたりすることができます。

// It would allow things like this.
getPipeline().procInstr(1).procInstr(2).procInstr(3);

// or more commonly
std::cout << getManiplator() << 5;

このより良い例については、この回答の終わりを見てください

テンポラリを参照にバインドすることはできません。そうすると、式の最後で破棄されるオブジェクトへの参照が生成され、ぶら下がった参照が残ります（これは整然としているため、標準では整然としています）。

ref（）によって返される値は有効な参照ですが、メソッドは、返されるオブジェクトの寿命に注意を払いません（そのコンテキスト内にその情報を持つことができないため）。あなたは基本的に次の同等のことをしました：

x& = const_cast<x&>(getX());

一時オブジェクトへのconst参照を使用してこれを実行しても問題ないのは、標準が一時オブジェクトの寿命を参照の寿命まで延長するため、一時オブジェクトの寿命がステートメントの終わりを超えて延長されるためです。

したがって、残っている唯一の質問は、なぜ標準が一時の参照を許可して、ステートメントの終わりを超えてオブジェクトの寿命を延ばしたくないのかということです。

これを行うと、コンパイラーが一時オブジェクトを正しく取得することが非常に難しくなるためです。これは一時的なものへのconst参照のために行われました。これは使用が制限されているため、オブジェクトのコピーを作成して何か便利なことをすることを余儀なくされましたが、機能が制限されています。

この状況について考えてみましょう：

int getI() { return 5;}
int x& = getI();

x++; // Note x is an alias to a variable. What variable are you updating.

この一時オブジェクトの寿命を延ばすことは非常に混乱するでしょう。
次は：

int const& y = getI();

使用して理解することが直感的であるコードを提供します。

値を変更する場合は、値を変数に返す必要があります。関数からオブジェクトをコピーして戻すコストを回避しようとしている場合（オブジェクトはコピーで構築されているようです（技術的にはそうです））。次に、コンパイラが「戻り値の最適化」に非常に優れていることを気にしないでください

なぜ C ++のFAQで議論されているのか（鉱山の太字）：

C ++では、非const参照は左辺値にバインドでき、const参照は左辺値または右辺値にバインドできますが、非const右辺値にバインドできるものはありません。これは、新しい値が使用される前に破棄される一時的な値を変更することから人々を保護するためです。例えば：

void incr(int& a) { ++a; }
int i = 0;
incr(i);    // i becomes 1
incr(0);    // error: 0 is not an lvalue

そのincr（0）が許可された場合、誰も見たことのない一時的な値が増加するか、さらに悪いことに、0の値は1になります。後者はばかげているように聞こえますが、実際には、値0を保持するためのメモリ位置は別として。

主な問題は

g(getx()); //error

は論理エラーです：gは結果を変更してgetx()いますが、変更されたオブジェクトを調べる機会がありません。gパラメータを変更する必要がない場合は、左辺値参照は必要ありません。値またはconst参照でパラメータを取得することができます。

const X& x = getx(); // OK

式の結果を再利用する必要がある場合があるため有効です。一時オブジェクトを扱っていることは明らかです。

しかし作ることは不可能です

X& x = getx(); // error

有効にすることなく有効にしg(getx())ます。これは、言語デザイナーがそもそも避けようとしていたことです。

g(getx().ref()); //OK

メソッドはのconst-nessのみを認識thisし、左辺値または右辺値のどちらで呼び出されたかがわからないため、有効です。

C ++ではいつものように、このルールの回避策はありますが、明示的にすることで、何をしているのかをコンパイラに知らせなければなりません。

g(const_cast<x&>(getX()));

これが許可されない理由についての最初の質問のように明確に回答されているようです：「それはおそらくエラーであるからです」。

FWIW、良いテクニックだとは思いませんが、どうすればできるかを見せたいと思いました。

非const参照を取得するメソッドに一時変数を渡したい場合がある理由は、呼び出し側のメソッドが気にしない参照によって返される値を意図的に破棄するためです。このようなもの：

// Assuming: void Person::GetNameAndAddr(std::string &name, std::string &addr);
string name;
person.GetNameAndAddr(name, string()); // don't care about addr

以前の回答で説明したように、それはコンパイルされません。しかし、これは（私のコンパイラで）正しくコンパイルされて機能します：

person.GetNameAndAddr(name,
    const_cast<string &>(static_cast<const string &>(string())));

これは、キャストを使用してコンパイラーに嘘をつくことができることを示しています。明らかに、未使用の自動変数を宣言して渡す方がずっときれいです。

string name;
string unused;
person.GetNameAndAddr(name, unused); // don't care about addr

この手法は、不要なローカル変数をメソッドのスコープに導入します。混乱やエラーを避けるためなど、なんらかの理由で後でメソッドで使用されないようにする場合は、ローカルブロックで非表示にすることができます。

string name;
{
    string unused;
    person.GetNameAndAddr(name, unused); // don't care about addr
}

-クリス

なぜあなたはこれまでにしたいX& x = getx();ですか？使用X x = getx();してRVOに依存するだけです。

悪意のある回避策には、「可変」キーワードが含まれます。実際、悪であることは読者の練習問題として残されています。またはこちらをご覧ください：http : //www.ddj.com/cpp/184403758

すばらしい質問です。これはより簡潔な回答の私の試みです（多くの有用な情報がコメントにあり、ノイズを掘り下げるのが難しいため）。

一時に直接バインドされた参照は、その寿命を延長します[12.2.5]。一方、別の参照で初期化された参照は（最終的に同じ一時的であっても）しません。これは理にかなっています（コンパイラは、その参照が最終的に何を参照するかを知りません）。

しかし、この全体の考えは非常に混乱しています。たとえばconst X &x = X();、一時的なx参照は参照と同じ長さになりますが、実際にはconst X &x = X().ref();何ref()が返されるかはわかりません。後者の場合、Xこの行の最後でのデストラクタが呼び出されます。（これは重要なデストラクタで観察できます。）

したがって、それは一般的に混乱し危険なようです（なぜオブジェクトのライフタイムに関するルールが複雑になるのでしょうか）。しかし、おそらくconst参照の必要性があったので、標準はこの動作を設定しています。

[ sbiコメントから]：const参照にバインドすると一時の有効期間が長くなるという事実は、意図的に追加された例外であることに注意してください（手動最適化を可能にするためにTTBOMK）。非const参照に一時をバインドすることはプログラマーのエラーである可能性が最も高いと見なされたため、非const参照に追加された例外はありませんでした。

すべての一時変数は、完全な式が終了するまで存続します。ただし、それらを使用するには、で使用するようなトリックが必要ですref()。それは合法です。異常なことが起こっていること（つまり、変更がすぐに失われる参照パラメーター）をプログラマーに思い出させることを除いて、余分なフープが飛び越える正当な理由はないようです。

[別のsbiコメント] Stroustrupが非const参照への右辺値のバインドを禁止する理由を（D＆Eで）与える理由は、Alexeyのg（）がオブジェクトを変更する場合（非constを取る関数から期待される）参照）、死ぬことになるオブジェクトを変更するため、変更された値を誰も取得できません。これはおそらく誤りであると彼は言う。

「上記のサンプルでは、​​非定数関数の呼び出しが許可されているため、一時オブジェクトが定数でないことは明らかです。たとえば、ref（）は一時オブジェクトを変更できます。」

この例では、getX（）はconst Xを返さないので、X（）。ref（）を呼び出すのとほぼ同じ方法でref（）を呼び出すことができます。非const refを返すため、非constメソッドを呼び出すことができますが、実行できないのは、refを非const参照に割り当てることです。

SadSidosのコメントとともに、これはあなたの3つのポイントを不正確にします。

アレクセイが求めていることを実行したい場合に共有したいシナリオがあります。Maya C ++プラグインでは、ノードアトリビュートに値を取得するために、次の操作を実行する必要があります。

MFnDoubleArrayData myArrayData;
MObject myArrayObj = myArrayData.create(myArray);   
MPlug myPlug = myNode.findPlug(attributeName);
myPlug.setValue(myArrayObj);

これは面倒なので、次のヘルパー関数を作成しました。

MPlug operator | (MFnDependencyNode& node, MObject& attribute){
    MStatus status;
    MPlug returnValue = node.findPlug(attribute, &status);
    return returnValue;
}

void operator << (MPlug& plug, MDoubleArray& doubleArray){
    MStatus status;
    MFnDoubleArrayData doubleArrayData;
    MObject doubleArrayObject = doubleArrayData.create(doubleArray, &status);
    status = plug.setValue(doubleArrayObject);
}

そして今、私は投稿の最初からコードを次のように書くことができます：

(myNode | attributeName) << myArray;

|から返された一時変数をバインドしようとしているため、Visual C ++の外部でコンパイルされないことが問題です。<<演算子のMPlug参照への演算子。このコードは何度も呼び出され、MPlugをあまりコピーしないほうがよいので、参考にしてください。2番目の関数が終了するまで、一時オブジェクトが必要です。

さて、これは私のシナリオです。ちょうど私がアレクセイが説明することをしたい例を示すと思いました。私はすべての批評と提案を歓迎します！

ありがとう。