（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。
（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。
（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
--------------------------------------------------

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：const 类型标识符 &引用名=目标变量名；

例1

int a ;

const int &ra=a;

ra=1; //错误

a=1; //正确

例2

string foo( );

void bar(string & s);

那么下面的表达式将是非法的：

bar(foo( ));

bar(“hello world”);

原因在于foo( )和”hello world”串都会产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

引用型参数应该在能被定义为const的情况下，尽量定义为const 。




对象也可以作为函数的参数传递给函数，其转递方法与传递其他类型的数据一样，可采用值传递和地址传递两种方法。

值传递：是把对象的拷贝而不是本身传递给函数，函数中对参数对象的任何修改都不会影响调用该函数的对象本身；

地址传递：调用该函数的对象与参数对象共用同一个地址，所以，函数对参数对象的任何修改都会影响调用该函数的对象本身。

注意：在C++中，下面三种对象需要调用拷贝构造函数（有时也称“复制构造函数”）

　　1) 一个对象作为函数参数，以值传递的方式传入函数体


　　2) 一个对象作为函数返回值，以值传递的方式从函数返回

　　3) 一个对象用于给另外一个对象进行初始化（常称为复制初始化）

　　当用引用变量做参数时，不调用拷贝构造函数，用传递引用的方式给函数传递一个对象的引用时，只传递了该对象的地址，系统消耗较小。在函数体内访问    形参，实际是访问了这个作为实参的对象。例如：void
 function（CTest &  test）；

　　Java中的引用传递是指： 例如：void
 function（CTest  test），没有&号


#include<iostream>
using namespace std;
class Tr{
public:
    //Tr(int n):i(n)  //构造函数最好这么写
    //{}
    Tr(int n)
    {
        i=n;
    }
    void set_i(int n)
    {i=n;}
    int get_i()
    {return i;}
private:
    int i;
};
void sqr_it1(Tr ob)
{
    ob.set_i(ob.get_i()*ob.get_i());
    cout<<"在函数sqr_it1内,形参对象obj的数据成员i="<<ob.get_i();
    cout<<endl;
}
void sqr_it2(Tr *obj)
{
    obj->set_i(obj->get_i()*obj->get_i());
    cout<<"在函数sqr_it2内，形参对象obj的数据成员i="<<obj->get_i();
    cout<<endl;
}
int main()
{
    Tr obj(10);
    cout<<"调用sqr_it前,实参对象obj的数据成员i="<<obj.get_i()<<endl;
    sqr_it1(obj);
    cout<<"调用sqr_it1后,实参对象obj的数据成员i="<<obj.get_i()<<endl;
    sqr_it2(&obj);
    cout<<"调用sqr_it2后,实参对象obj的数据成员i="<<obj.get_i()<<endl;
    return 0;
}



调用sqr_it前,实参对象obj的数据成员i=10 

在函数sqr_it1内,形参对象obj的数据成员i=100 

调用sqr_it1后,实参对象obj的数据成员i=10 
(此时，由于是以值传递，obj的数据成员i没有变化，还是原先的10) 
在函数sqr_it2内，形参对象obj的数据成员i=100 

调用sqr_it2后,实参对象obj的数据成员i=100 
(此时，由于是以地址传递，obj的数据成员i发生变化，为sqr_it2中的值100)

 

通常的原则是：①对于凡是包含动态分配成员或包含指针成员的类都应该提供拷贝构造函数；②在提供拷贝构造函数的同时，还应该考虑重载"="赋值操作符号。

复制初始化

　　以下讨论中将用到的例子：



class CExample
{
　　public:
　　CExample(){pBuffer=NULL; nSize=0;}
　　~CExample(){delete []pBuffer;}
　　void Init(int n){ pBuffer=new char[n]; nSize=n;}
　　private:
　　char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
　　int nSize;
};


　　这个类的主要特点是包含指向其他资源的指针，pBuffer指向堆中动态分配的一段内存空间。


 


int main(int argc, char* argv[])
{
　　CExample theObjone;
　　theObjone.Init(40);
　　//现在需要另一个对象,并将它初始化为theObjone

　　CExample theObjtwo=theObjone;
　　...
}


　　语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。


 　　　回顾一下此语句的具体过程：首先建立对象theObjtwo，并调用其构造函数，然后成员被复制初始化。

　　其完成方式是内存拷贝，复制所有成员的值。完成后，theObjtwo.pBuffer==theObjone.pBuffer。

 　　　即它们将指向同样的地方，指针虽然复制了，但所指向的空间并没有复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。所以需要采用必要的手段来避免此类情况：可以在构造函数中添加操作来解决指针成员的这种问题。

　　所以C++语法中除了提供缺省形式的构造函数外，还规范了另一种特殊的构造函数：拷贝构造函数，一种特殊的构造函数重载。上面的语句中，如果类中定义了拷贝构造函数，在对象复制初始化时，调用的将是拷贝构造函数，而不是缺省构造函数。在拷贝构造函数中，可以根据传入的变量，复制指针所指向的资源。

　　拷贝构造函数的格式为：类名（const 类名& 对象名）;//拷贝构造函数的原型，参数是常量对象的引用。由于拷贝构造函数的目的是成员复制，不应修改原对象，所以建议使用const关键字。

　　提供了拷贝构造函数后的CExample类定义为：


class CExample
{
　　public:
　　CExample(){pBuffer=NULL; nSize=0;}
　　~CExample(){delete []pBuffer;}
　　CExample(const CExample&); //拷贝构造函数
　　void Init(int n){ pBuffer=new char[n]; nSize=n;}
　　private:
　　char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
　　int nSize;
};

　　CExample::CExample(const CExample& RightSides) //拷贝构造函数的定义
　{
 
　　nSize=RightSides.nSize; //复制常规成员
　　pBuffer=new char[nSize]; //复制指针指向的内容
　　memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));
　}

 



　　这样，定义新对象，并用已有对象初始化新对象时，CExample(const CExample& RightSides)将被调用，而已有对象用别名RightSides传给构造函数，以用来作复制。

对象按值传递

　　下面介绍拷贝构造函数的另一种调用：当对象直接作为参数传给函数时，函数将建立对象的临时拷贝，这个拷贝过程也将调用拷贝构造函数。例如：



     BOOL testfunc(CExample obj);
　　testfunc(theObjone); //对象直接作为参数。
　　BOOL testfunc(CExample obj)
　　{
　    　//针对obj的操作实际上是针对复制后的临时拷贝进行的
　　}

　　还有一种情况，也是与临时对象有关：当函数中的局部对象作为返回值被返回给函数调者时，也将建立此局部对象的一个临时拷贝，拷贝构造函数也将被调用。
　　CTest func()
 　{
　　CTest theTest;
　　return theTest;
　　}        




　总结：当某对象是按值传递时（无论是作为函数参数，还是作为函数返回值），编译器都会先建立一个此对象的临时拷贝，而在建立该临时拷贝时就会调用类的拷贝构造函数。

 

拷贝构造函数的实现：
 
　　类名::类名（类名&对象名）//拷贝构造函数的实现/定义
 
　　{函数体}

在初学C++的时候，学到引用结合函数运用的部分，一直有一个疑惑：函数的参数应该是对象还是对象的引用？返回值选择返回对象还是对象的引用？二者又有什么区别？
首先来看，函数参数方面：

记住：编写使用对象作为参数的函数时，应按引用而不是按值来传对象，原因如下
1.提高效率，按值传递（直接传递对象）涉及到生成了临时拷贝，即调用复制构造函数，然后调用析构函数，调用这些函数需要时间，比起直接传递对象的引用花费的时间要多得多
2.在继承中使用虚函数时，被定义为接受基类引用的函数可以接受派生类对象的引用（基类指针或引用可以指向派生类）
其次，返回值方面，有两种情况：
1.当该函数返回的是通过引用或指针传递的对象，则返回值应为对象的引用，如下
A & Compare(const A &a)const //返回A类型的引用
{
if(this->weight>a.weight)
    return *this  //返回通过指针传递的对象
else
    return a //返回通过引用传递的对象
}

2.当该函数返回的是在函数中创建的临时对象时，则应返回对象，通常用于重载运算符‘+ - × ÷’的时候，如下
A operator + (const A &a)const //重载‘+’，返回A类型对象
{
return A(this->weight+a.weight)//返回了一个临时对象
}

#include 

using namespace std;

class A

{

public :

A(){x=0;y=0;}

A(int i,int j)

{

x=i;y=j;

}

void SetValue(int i,int j)

{

x=i;y=j;

}

void Disp()

{

cout<<x<<","<<y<<endl;

}

private:

int x,y;

};

void fun(A &r)  //对象引用作形参

{

r.SetValue(10, 20);

}

int main(int argc, const char * argv[]) {

A a(1,2);

fun(a);

a.Disp();

return 0;

}

输出:

10,20

Program ended with exit code: 0