我正在学习通过引用传递，这是我做的测试:

#include <iostream>

using namespace std;

int i = 0;

//If this is uncommented, compiler gives ambiguous definition error.
//void paramCheck (string s) {
//  cout << ++i << ". Param is var.\n";
//}

void paramCheck (const string& s) {
    cout << ++i << ". Param is const ref.\n";
}

void paramCheck (string& s) {
    cout << ++i  << ". Param is non-const ref.\n";
}

void paramCheck (const string&& s) {
    cout << ++i  << ". Param is const rvalue-reference.\n";
}

void paramCheck (string&& s) {
    cout << ++i  << ". Param is non-const rvalue-reference.\n";
}


int main(int argc, char **argv) {
    //Function call test
    paramCheck("");

    paramCheck(string{""});

    string s3{""};
    paramCheck(s3);

    const string s4{""};
    paramCheck(s4);

    //Illegal
    //string& s{""};
    //paramCheck(s);

    const string& s5{s3};
    paramCheck(s5);

    string&& s6{""};
    paramCheck(s6);

    //Illegal
    //const string&& s{s1};
    //onstFP(s);

    //Reference test
    string a = s3;
    a = "a changed s3";
    cout << s3;

    {
    string& b = s3;
    b = "b changed after assigning s3\n";
    cout << "s3 is now " <<s3;

    b = s4;
    b = "b changed after assigning s4\n";
    cout << "s3 is now " <<s3;
    cout << "s4 is now " <<s4;
    }

    cin.get();
    return 0;
}

这是我得到的结果:

1. Param is non-const rvalue-reference.
2. Param is non-const rvalue-reference.
3. Param is non-const ref.
4. Param is const ref.
5. Param is const ref.
6. Param is non-const ref.
s3 is now b changed after assigning s3
s3 is now b changed after assigning s4
s4 is now

我的问题是:

1. 如果我们传递一个常量表达式，它总是会触发非常量右值引用？在什么情况下它会触发常量右值引用(以及为什么 s6 不触发它？)

2. 为什么非常量引用和常量右值引用是非法的？

3. 我预计a不能改变s3，但为什么内部作用域中的b可以改变s3？如果将新对象 s3 分配给 b 就是分配一个新引用，为什么当我将 s4 分配给它时，s3 发生了变化，之后 s4 为空？

很抱歉问了太多问题......当所有问题都得到回答后我会加分:)引用只是把我的困惑从指针带到了一个全新的水平。

我不知道如何增加点数...所以将等待 2 天直到有资格获得赏金然后选择答案。

最佳答案

先上代码

paramCheck(""); //constructs a temporary. temporaries bind to `string&&`
paramCheck(string{""}); //constructs a temporary. temporaries bind to `string&&`
string s3{""};
paramCheck(s3); //passes a reference to an existing string: `string&`
const string s4{""};
paramCheck(s4); //passes a reference to an existing string+const: `const string&`
//Illegal
//string& s{""}; //cannot assign a temporary to a non-const l-reference
                 //what would s refer to when the temporary "dies"?
                 //`const string&` would have worked though
//paramCheck(s); //passes a reference to an existing string+const: `const string&`
const string& s5{s3}; //s5 is s3, but with `const`. 
paramCheck(s5); //passes a reference to an existing string+const: `const string&`
string&& s6{""}; //r-references extend the life of temporaries.
paramCheck(s6); //passes a reference to an existing strong: `string&`
//const string&& s{s1}; //temporaries can be extended by `T&&` or `const T&` only.

//Reference test
string a = s3; //a is a _copy_ of s3
a = "a changed s3"; //so changing the copy doesn't effect the origional.
cout << s3; //s3 is still blank, it hasn't changed.

{
string& b = s3; //b isn't really a "reference" to `s3`".  `b` _IS_ `s3`.
b = "b changed after assigning s3\n"; //since `b` IS `s3`, this changes `s3`.
cout << "s3 is now " <<s3;

b = s4; //`b` _IS_ `s3`, so you just changed `s3` again.
b = "b changed after assigning s4\n";
cout << "s3 is now " <<s3;
cout << "s4 is now " <<s4; //s4 is still blank, it hasn't changed.
}

然后是问题:

If we pass a constant expression, it always triggers non-constant rvalue-reference? Under what condition it will trigger constant rvalue-reference (and why s6 is not trigging it?)

现有对象将作为 string& 或 const string& 传递，具体取决于它们是否为 const。它们也可以作为 string 复制。临时对象将作为 string&& 传递，但也可以作为 string 复制。 有方法可以触发const string&&，但没有理由这样做，所以这无关紧要。 They're shown here .

Why non-constant reference and constant rvalue-reference are illegal?

标准明确指出只有 const string& 和 string&& 会延长临时对象的生命周期，但我不确定他们为什么没有提到 string& 和 const string&&。

I expected a cannot change s3, but why b in the inner scope can change s3? If assigning a new object s3 to b is assigning a new reference, why when I assign s4 to it and s3 got changed and s4 is empty afterwards?

您将 b 初始化为对 s3 的引用。不是拷贝，而是引用。这意味着 b 现在指的是 s3 永远，无论如何。当您键入 b = "b changed after assigning s3\n"; 时，这与 s3 = "b changed after assigning s3\n"; 完全相同。当您键入 b = s4; 时，这与 s3 = s4 完全相同。这就是引用。它们不能“重新安装”。

关于c++ - 通过引用传递、常量引用、右值引用还是常量右值引用？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17980570/