代码弄懂C++值传递，引用传递，指针对象传递

#include "stdafx.h"
#include<iostream>

/*代码弄懂C++值传递，引用传递，指针对象传递*/
using namespace std;
class MyClass
{
public:
    int n;
    void method();
};
//值传递
 void change1(int n){
    n++;
    cout<<"内部int n="<<n<<endl;
}

//引用传递
void change2(int & n){
    n++;
    cout<<"内部int &n="<<n<<endl;
}
 //指针传递
void change3(int * n){
    *n=*n+1;
    cout<<"内部int *n="<<*n<<endl; 
 } 

/*
值对象传递
当形参是对象时，实参要求是相同类的对象名，C++不能对类对象进行任何隐式类型转换。此时形参是实参对象的副本。 
采用这样的值传递方式会增加函数调用在空间、时间上的开销，特 别是当数据成员的长度很大时，开销会急剧增加。 
实际编程中，传递对象时需要考虑类的规模带来的调用开销，如果开销很大时建议不用对象作为函数参数。
*/
void change4(MyClass mc)
{
    mc.n=11;
    cout<<"值对象传递内部MyClass.n="<<mc.n<<endl;
}
/*
引用对象传递
当形参是对象引用时，实参要求是同类的对象，其功能与对象指针相似。 
此时函数形参对象实际上是实参对象的别名，为同一个对象。
在函数中若修改了形参对象本质上就是修改实参对象。
----因此，使用对象引用作为函数参数可以向主调函数传回变化后的对象。-----
*/
void change5(MyClass &mc)
{
    mc.n=11;
    cout<<"引用对象传递内部&MyClass.n="<<mc.n<<endl;
}
/*
指针对象传递 
当形参是对象指针时，实参要求是同类对象的指针，C++不能对对象指针进行任何隐式类型转换。
函数调用时，无论类多大规模，传递的参数是一个地址值，其开销非常小。
采用地址传递方式，在函数中若按间接引用方式修改了形参对象本质上就是修改实参对象。
----因此，使用对象指针作为函数参数可以向主调函数传回变化后的对象。----- 
*/
void change6(MyClass *mc)
{
    mc->n=11;
    cout<<"指针对象传递内部*MyClass.n="<<mc->n<<endl;
}

int main()
{ 
    int n=10;
    change1(n);
    cout<<"外部 int n="<<n<<endl;

    n=10;
    change2(n);
    cout<<"外部int &n="<<n<<endl;

    n=10;
    change3(&n);
    cout<<"外部int *n="<<n<<endl;

    MyClass mc;
    mc.n =10;
    change4(mc);
    cout<<"值对象传递外部MyClass.n="<<mc.n<<endl;

    mc.n =10;
    change5(mc);
    cout<<"引用对象传递外部&MyClass.n="<<mc.n<<endl;

    mc.n =10;
    change6(&mc);
    cout<<"指针对象传递外部*MyClass.n="<<mc.n<<endl;
    /*
    引用与指针的区别：指针与引用的另一个重要的不同是指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变。
    */
    int s1=1;
    int s2=2;
    int & rs = s1; // rs 引用 s1
    rs = s2; // rs 仍旧引用s1,但是 s1的值现在是 2
    cout<<"引用：s1="<<s1<<" rs="<<rs<<endl;

    s1=1;
    s2=2;
    int * ps = &s1; // ps 指向 s1
    ps = &s2; // ps 现在指向 s2;s1 没有改变是1
    cout<<"指针：ps="<<*ps<<" s1="<<s1<<endl;

    getchar();
    return true;
}