c++-值传递与引用传递在返回值和形参中

x.a = 1;
y.a = 2;

形参值传递 返回值值传递

A func1(A b)
{
    cout << "调用了func" << endl;
    return b;
    //隐藏了 A z = b;y = z;
}
y = func1(x);

结果

调用func1：参数值传递 返回值值传递
---------------------------
---------------------------
调用了拷贝构造函数 //创建一个形参b 将变量x拷贝给形参b
调用了func //执行函数
调用了拷贝构造函数 //创建一个匿名的临时变量z 将形参b拷贝给临时变量z
调用了赋值运算符 //将临时变量z赋值给变量b 因为用的是=号 所以是赋值运算符
x:1
y:2

形参值传递 返回值引用传递(细看)

A& func2(A b)
{
    cout << "调用了func" << endl;
    return b;
}
y = func2(x);//y还是一个变量 这里返回的是b的引用
//隐藏了 A&z = b;  y = z;(y = b)//

结果

调用func2：参数值传递 返回值引用传递
---------------------------
---------------------------
调用了拷贝构造函数 //创建一个形参b 将实参x拷贝给形参b
调用了func
调用了赋值运算符//因为是引用传递 不会创建临时变量 会创建一个临时引用z 临时引用z引用形参b 然后y=z实际上就是y=b但是b是形参 就会被释放 形成垃圾值 同下面的那个规定 局部变量的生命周期会和这个引用相同 但是这个引用也是个临时引用 所以一起在函数结束时销毁
x:1
y:15989876

如果是引用一个临时变量

A func2(A b)
{
    cout << "调用了func" << endl;
    return b;
    //隐藏了 A z = b;A& p = z;
}
const A& p = func2(x);
x = 1;
y = 1;

规定

C++规定，如果有临时对象有一个引用，那么这个临时对象的生存期将延长到和这个引用相同
所以临时变量z的生存周期就和y相同了

形参引用传递 返回值值传递(临时变量有引用)

A func3(A &b)
{
    cout << "调用了func" << endl;
    return b;
    //隐藏了A z = b;(A z = x) y = z;
}
y = func3(x);

结果

调用func3：参数引用传递 返回值值传递
---------------------------
---------------------------
//因为是引用传递所以形参b只是共同管理实参x的地址空间 不会产生拷贝
调用了func
调用了拷贝构造函数//因为是值传递 所以会先创建一个临时变量z 将变量x拷贝给z
调用了赋值运算符 //临时变量将值赋值给变量y
x:1
y:1

形参引用传递 返回值引用传递

A& func4(A &b)
{
    cout << "调用了func" << endl;
    return b;
    //隐藏了 int &z = b;(int &z = x)  y = z;(y=x)
}
y = func4(x);

结果

调用func4：参数引用传递 返回值引用传递
---------------------------
---------------------------
调用了func
调用了赋值运算符//将x变量赋值给y
x:1
y:1

class A
{
public:
    int a;
    A()
    {
        cout << "调用了默认构造函数" << endl;
    }
    A(const A& b)
    {
        a = b.a;
        cout << "调用了拷贝构造函数" << endl;
    }
    A& operator=(const A &b)
    {
        this->a = b.a;
        cout << "调用了赋值运算符" << endl;
        return *this;
    }
};
A func1(A b)
{
    cout << "调用了func" << endl;
    return b;
}
A& func2(A b)
{
    cout << "调用了func" << endl;
    return b;
}
A func3(A &b)
{
    cout << "调用了func" << endl;
    return b;
}
A& func4(A &b)
{
    cout << "调用了func" << endl;
    return b;
}
int main()
{
    cout << "A x" << endl;
    A x;
    cout << "A y" << endl;
    A y;
    x.a = 1;
    y.a = 2;
    cout << "x=y" << endl;
    cout << "---------------------------" << endl;
    cout << "---------------------------" << endl;
    x = y;
    x.a = 1;
    y.a = 2;
    cout << "调用func1：参数值传递 返回值值传递" << endl;
    cout << "---------------------------" << endl;
    cout << "---------------------------" << endl;
    y = func1(x);
    cout << "x:" << x.a << endl;
    cout << "y:" << y.a << endl;
    x.a = 1;
    y.a = 2;
    cout << "调用func2：参数值传递 返回值引用传递" << endl;
    cout << "---------------------------" << endl;
    cout << "---------------------------" << endl;
    y = func2(x);
    cout << "x:" << x.a << endl;
    cout << "y:" << y.a << endl;
    x.a = 1;
    y.a = 2;
    cout << "调用func3：参数引用传递 返回值值传递" << endl;
    cout << "---------------------------" << endl;
    cout << "---------------------------" << endl;
    y = func3(x);
    cout << "x:" << x.a << endl;
    cout << "y:" << y.a << endl;
    x.a = 1;
    y.a = 2;
    cout << "调用func4：参数引用传递 返回值引用传递" << endl;
    cout << "---------------------------" << endl;
    cout << "---------------------------" << endl;
    y = func4(x);
    cout << "x:" << x.a << endl;
    cout << "y:" << y.a << endl;
    return 0;
}

A x
调用了默认构造函数
A y
调用了默认构造函数
x=y
---------------------------
---------------------------
调用了赋值运算符
调用func1：参数值传递 返回值值传递
---------------------------
---------------------------
调用了拷贝构造函数
调用了func
调用了拷贝构造函数
调用了赋值运算符
x:1
y:2
调用func2：参数值传递 返回值引用传递
---------------------------
---------------------------
调用了拷贝构造函数
调用了func
调用了赋值运算符
x:1
y:15989876
调用func3：参数引用传递 返回值值传递
---------------------------
---------------------------
调用了func
调用了拷贝构造函数
调用了赋值运算符
x:1
y:1
调用func4：参数引用传递 返回值引用传递
---------------------------
---------------------------
调用了func
调用了赋值运算符
x:1
y:1