C++ 值传递、指针传递、引用传递详解

C++ 值传递、指针传递、引用传递详解

最近写了几篇深层次讨论数组和指针的文章，其中提到了“C语言中，所有非数组的形式参数传递均以值传递形式”

数组和指针背后——内存角度

语义"陷阱"---数组和指针

而关于值传递，指针传递，引用传递这几个方面还会存在误区， 所有我觉的有必要在这里也说明一下~

下文会通过例子详细说明哦

值传递：

形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的（实参->形参），参数的值只能传入，

不能传出。当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。

指针传递：

形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作

引用传递：

形参相当于是实参的“别名”，对形参的操作其实就是对实参的操作，在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈

中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过

栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

 

理论性的就不多说，

下面的代码对此作出了细致解释（从实参，形参在内存中存放地址的角度 说明了问题的本质，容易理解  ）

 1 #include<iostream>
 2 using namespace std;
 3 //值传递
 4  void change1(int n){
 5     cout<<"值传递--函数操作地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址 
 6     n++;
 7 }
 8 
 9 //引用传递
10 void change2(int & n){
11     cout<<"引用传递--函数操作地址"<<&n<<endl; 
12     n++;
13 }
14  //指针传递
15 void change3(int *n){
16      cout<<"指针传递--函数操作地址 "<<n<<endl; 
17     *n=*n+1;
18  } 
19 int     main(){
20     int n=10;
21     cout<<"实参的地址"<<&n<<endl;
22     change1(n);
23     cout<<"after change1() n="<<n<<endl;
24     change2(n);
25     cout<<"after change2() n="<<n<<endl;
26     change3(&n);
27     cout<<"after change3() n="<<n<<endl;
28     return true;
29 }

运行结果如下，（不同的机器可能会有所差别）

可以看出，实参的地址为0x22ff44

采用值传递的时候，函数操作的地址是0x22ff20并不是实参本身，所以对它进行操作并不能改变实参的值

再看引用传递，操作地址就是实参地址 ，只是相当于实参的一个别名，对它的操作就是对实参的操作

接下来是指针传递，也可发现操作地址是实参地址

那么，引用传递和指针传递有什么区别吗？

  引用的规则： 
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。 

（2）不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。 
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。 

指针传递的实质：

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，

即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的

任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针本身的地址值不会变）如果理解不了大可跳过这段

指针传递和引用传递一般适用于：

函数内部修改参数并且希望改动影响调用者。对比指针/引用传递可以将改变由形参“传给”实参（实际上就是直接在实参的内存上修改，

不像值传递将实参的值拷贝到另外的内存地址中才修改）。

另外一种用法是：当一个函数实际需要返回多个值，而只能显式返回一个值时，可以将另外需要返回的变量以指针/引用传递

给函数，这样在函数内部修改并且返回后，调用者可以拿到被修改过后的变量，也相当于一个隐式的返回值传递吧。

 

 

以下是我觉得关于指针和引用写得很不错的文章，大家可参照看一下，原文出处地址：http://xinklabi.iteye.com/blog/653643 

从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它可以被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

而引用是一个别名，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化，而且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。

在C++中，指针和引用经常用于函数的参数传递，然而，指针传递参数和引用传递参数是有本质上的不同的：

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针本身的地址值不会变）

而在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。

为了进一步加深大家对指针和引用的区别，下面我从编译的角度来阐述它们之间的区别：

程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。

最后，总结一下指针和引用的相同点和不同点：

★相同点：

●都是地址的概念；

指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。

★不同点：

●指针是一个实体，而引用仅是个别名；

●引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”，指针可以“见异思迁”；

●引用没有const，指针有const，const的指针不可变；（具体指没有int& const a这种形式，而const int& a是有     的，  前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）

●引用不能为空，指针可以为空；

●“sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身的大小；

●指针和引用的自增(++)运算意义不一样；

●引用是类型安全的，而指针不是 (引用比指针多了类型检查）

一、引用的概念

引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。
例如： Point pt1(10,10);
Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。
需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后：
pt1.offset（2，2）；
pt1和pt2都具有（12，12）的值。
引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才
初始化它。例如下面语句是非法的：
Point &pt3；
pt3=pt1；
那么既然引用只是某个东西的同义词，它有什么用途呢？
下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。 

二、引用参数

1、传递可变参数
传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。
所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现
两整数变量值交换的c程序如下：
void swapint(int *a,int *b)
{
int temp;
temp=*a;
a=*b;
*b=temp;
}

使用引用机制后，以上程序的c++版本为：
void swapint(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}
调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。

2、给函数传递大型对象
当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的
副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类： 
const maxCard=100; 
Class Set 
{
int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。 
int card; // 集合中元素的个数。 
public:
Set () {card=0;} //构造函数
friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象作为传值参数
// friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用作为传值参数 
...
}
先考虑集合交集的实现
Set operator *( Set Set1,Set Set2)
{
Set res;
for(int i=0;i<Set1.card;++i)
for(int j=0;j>Set2.card;++j)
if(Set1.elems[i]==Set2.elems[j])
{
res.elems[res.card++]=Set1.elems[i];
break;
}
return res;
}
由于重载运算符不能对指针单独操作，我们必须把运算数声明为 Set 类型而不是 Set * 。
每次使用*做交集运算时，整个集合都被复制，这样效率很低。我们可以用引用来避免这种情况。
Set operator *( Set &Set1,Set &Set2)
{ Set res;
for(int i=0;i<Set1.card;++i)
for(int j=0;j>Set2.card;++j)
if(Set1.elems[i]==Set2.elems[j])
{
res.elems[res.card++]=Set1.elems[i];
break;
}
return res;
}

三、引用返回值

如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用：
double &max(double &d1,double &d2)
{
return d1>d2?d1:d2;
}
由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1：
max(x,y)+=1.0;

C语言函数调用三种方式传值调用,引用调用和传地址调

我想，你只要看了C语言上关于传值函数调用的测试题，一切都会了然于胸：

1. 考题一：程序代码如下：
void Exchg1(int x, int y)
{
int tmp;
tmp=x;
x=y;
y=tmp;
printf(“x=%d,y=%d\n”,x,y)
}
void main()
{
int a=4,b=6;
Exchg1 (a,b) ;
printf(“a=%d,b=%d\n”,a,b)
}
输出的结果：
x=____, y=____
a=____, b=____
问下划线的部分应是什么，请完成。

2. 考题二：代码如下。
Exchg2(int *px, int *py)
{
int tmp=*px;
*px=*py;
   *py=tmp;
print(“*px=%d,*py=%d\n”,*px,*py);
}
main()
{
int a=4;
int b=6;
      Exchg2(&a,&b);
      Print(“a=%d,b=%d\n”, a, b);
}
输出的结果为：
*px=____, *py=____
a=____, b=____
问下划线的部分应是什么，请完成。

3. 考题三：
Exchg2(int &x, int &y)
{
   int tmp=x;
   x=y;
   y=tmp;
print(“x=%d,y=%d\n”,x,y);
}
main()
{
int a=4;
int b=6;
      Exchg2(a,b);
      Print(“a=%d,b=%d\n”, a, b);
}

二． 函数参数传递方式之一：值传递

1． 值传递的一个错误认识
    先看题一中Exchg1函数的定义：
void Exchg1(int x, int y)   //定义中的x,y变量被称为Exchg1函数的形式参数
{
int tmp;
tmp=x;
x=y;
y=tmp;
printf(“x=%d,y=%d\n”,x,y)
}
问：你认为这个函数是在做什么呀？
答：好像是对参数x,y的值对调吧？
    请往下看，我想利用这个函数来完成对a,b两个变量值的对调，程序如下：
void main()
{
int a=4,b=6;
Exchg1 (a,b)     //a,b变量为Exchg1函数的实际参数。
/ printf(“a=%d,b=%d\n”,a,b)
}
    我问：Exchg1 ()里头的 printf(“x=%d,y=%d\n”,x,y)语句会输出什么啊？
    我再问：Exchg1 ()后的 printf(“a=%d,b=%d\n”,a,b)语句输出的是什么？
    程序输出的结果是：
x=6 , y=4
a=4 , b=6 //为什么不是a=6,b=4呢？

    奇怪，明明我把a,b分别代入了x,y中，并在函数里完成了两个变量值的交换，为什么a,b变量值还是没有交换（仍然是a==4,b==6，而不是a==6,b==4）？如果你也会有这个疑问，那是因为你跟本就不知实参a,b与形参x,y的关系了。

2． 一个预备的常识
为了说明这个问题，我先给出一个代码：
int a=4;
int x;
x=a;
x=x+3;
    看好了没，现在我问你：最终a值是多少，x值是多少?
    （怎么搞的，给我这个小儿科的问题。还不简单，不就是a==4 x==7嘛！）
    在这个代码中，你要明白一个东西：虽然a值赋给了x，但是a变量并不是x变量哦。我们对x任何的修改，都不会改变a变量。呵呵！虽然简单，并且一看就理所当然，不过可是一个很重要的认识喔。

3． 理解值传递的形式
看调用Exch1函数的代码：

main()
{
int a=4,b=6;
Exchg1(a,b) //这里调用了Exchg1函数       
printf(“a=%d,b=%d”,a,b)
}

Exchg1(a,b)时所完成的操作代码如下所示。
int x=a;//←
int y=b;//←注意这里，头两行是调用函数时的隐含操作
int tmp;
tmp=x;
x=y;
y=tmp;
    请注意在调用执行Exchg1函数的操作中我人为地加上了头两句：
int x=a;
int y=b;
    这是调用函数时的两个隐含动作。它确实存在，现在我只不过把它显式地写了出来而已。问题一下就清晰起来啦。（看到这里，现在你认为函数里面交换操作的是a,b变量或者只是x,y变量呢？）
    原来 ，其实函数在调用时是隐含地把实参a,b 的值分别赋值给了x,y，之后在你写的Exchg1函数体内再也没有对a,b进行任何的操作了。交换的只是x,y变量。并不是a,b。当然a,b的值没有改变啦！函数只是把a,b的值通过赋值传递给了x,y，函数里头操作的只是x,y的值并不是a,b的值。这就是所谓的参数的值传递了。
    哈哈，终于明白了，正是因为它隐含了那两个的赋值操作，才让我们产生了前述的迷惑（以为a,b已经代替了x,y，对x,y的操作就是对a,b的操作了，这是一个错误的观点啊！）。

三． 函数参数传递方式之二：地址传递
继续——地址传递的问题！
看题二的代码：
Exchg2(int *px, int *py)
{
int tmp=*px;
*px=*py;
*py=tmp;
print(“*px=%d,*py=%d\n”,*px,*py);
}
main()
{
int a=4;
int b=6;
      Exchg2(&a,&b);
      Print(“a=%d,b=%d\n”, a, b);
}
它的输出结果是：
*px=6,*py=4
a=6,b=4

    看函数的接口部分：Exchg2(int *px,int *py)，请注意：参数px,py都是指针。
    再看调用处：Exchg2(&a, &b);
    它将a的地址（&a）代入到px，b的地址(&b)代入到py。同上面的值传递一样，函数调用时作了两个隐含的操作：将&a，&b的值赋值给了px,py。
px=&a;
py=&b;
    呵呵！我们发现，其实它与值传递并没有什么不同，只不过这里是将a,b的地址值传递给了px,py，而不是传递的a,b的内容，而（请好好地在比较比较啦）
    整个Exchg2函数调用是如下执行的：
px=&a;   //
py=&b;   //请注意这两行，它是调用Exchg2的隐含动作。
int tmp=*px;
*px=*py;
*py=tmp;
print(“*px=%d,*py=%d\n”,*px,*py);
    这样，有了头两行的隐含赋值操作。我们现在已经可以看出，指针px,py的值已经分别是a,b变量的地址值了。接下来，对*px，*py的操作当然也就是对a,b变量本身的操作了。所以函数里头的交换就是对a,b值的交换了，这就是所谓的地址传递（传递a,b的地址给了px,py），你现在明白了吗？

四． 函数参数传递方式之三：引用传递(其实可以将引用传递看作是C++比C拓展的东西)
    看题三的代码：
Exchg3(int &x, int &y) //注意定义处的形式参数的格式与值传递不同
{
   int tmp=x;
   x=y;
   y=tmp;
print(“x=%d,y=%d\n”,x,y);
}
main()
{
int a=4;
int b=6;
      Exchg3(a,b); //注意：这里调用方式与值传递一样
      Print(“a=%d,b=%d\n”, a, b);
}
输出结果：
x=6, y=4
a=6, b=4   //这个输出结果与值传递不同。
    看到没有，与值传递相比，代码格式上只有一处是不同的，即在定义处：
Exchg3(int &x, int &y)。
    但是我们发现a与b的值发生了对调。这说明了Exchg3(a,b)里头修改的是a,b变量，而不只是修改x,y了。
    我们先看Exchg3函数的定义处Exchg3(int &x,int &y)。参数x,y是int的变量，调用时我们可以像值传递(如： Exchg1(a,b); )一样调用函数(如： Exchg3(a,b); )。但是x,y前都有一个取地址符号&。有了这个，调用Exchg3时函数会将a,b 分别代替了x,y了，我们称x,y分别引用了a,b变量。这样函数里头操作的其实就是实参a,b本身了，也就是说函数里是可以直接修改到a,b的值了。

   最后对值传递与引用传递作一个比较：

1． 在函数定义格式上有不同：
值传递在定义处是：Exchg1(int x, int y);
引用传递在这义处是：Exchg1(int &x, int &y);

2． 调用时有相同的格式：
值传递：Exchg1(a,b);
引用传递：Exchg3(a,b);

3． 功能上是不同的：
值传递的函数里操作的不是a,b变量本身，只是将a,b值赋给了x,y函数里操作的只是x,y变量而不是a,b，显示a,b的值不会被Exchg1函数所修改。
引用传递Exchg3(a,b)函数里是用a,b分别代替了x,y。函数里操作的是a,b。

 

 

C++中引用传递与指针传递区别（进一步整理）

• 博客分类： 
• C/C++

C C++ C# J# 

从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它可以被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

而引用是一个别名，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化，而且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。

在C++中，指针和引用经常用于函数的参数传递，然而，指针传递参数和引用传递参数是有本质上的不同的：

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针本身的地址值不会变）

而在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

引用传递和指针传递是不同的，虽然它们都是在被调函数栈空间上的一个局部变量，但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数，如果改变被调函数中的指针地址，它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量，那就得使用指向指针的指针，或者指针引用。

为了进一步加深大家对指针和引用的区别，下面我从编译的角度来阐述它们之间的区别：

程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改，因此指针可以改变其指向的对象（指针变量中的值可以改），而引用对象则不能修改。

最后，总结一下指针和引用的相同点和不同点：

★相同点：

●都是地址的概念；

指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。

★不同点：

●指针是一个实体，而引用仅是个别名；

●引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”，指针可以“见异思迁”；

●引用没有const，指针有const，const的指针不可变；（具体指没有int& const a这种形式，而const int& a是有     的，  前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）

●引用不能为空，指针可以为空；

●“sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身的大小；

●指针和引用的自增(++)运算意义不一样；

●引用是类型安全的，而指针不是 (引用比指针多了类型检查

 

一、引用的概念 引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。 例如： Point pt1(10,10); Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。 需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后： pt1.offset（2，2）； pt1和pt2都具有（12，12）的值。 引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才 初始化它。例如下面语句是非法的： Point &pt3； pt3=pt1； 那么既然引用只是某个东西的同义词，它有什么用途呢？ 下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。  二、引用参数 1、传递可变参数 传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。 所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现 两整数变量值交换的c程序如下： void swapint(int *a,int *b) { int temp; temp=*a; a=*b; *b=temp; } 使用引用机制后，以上程序的c++版本为： void swapint(int &a,int &b) { int temp; temp=a; a=b; b=temp; } 调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。 2、给函数传递大型对象 当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的 副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类：  const maxCard=100;  Class Set  { int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。  int card; // 集合中元素的个数。  public: Set () {card=0;} //构造函数 friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象作为传值参数 // friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用作为传值参数  ... } 先考虑集合交集的实现 Set operator *( Set Set1,Set Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems[i]==Set2.elems[j]) { res.elems[res.card++]=Set1.elems[i]; break; } return res; } 由于重载运算符不能对指针单独操作，我们必须把运算数声明为 Set 类型而不是 Set * 。 每次使用*做交集运算时，整个集合都被复制，这样效率很低。我们可以用引用来避免这种情况。 Set operator *( Set &Set1,Set &Set2) { Set res; for(int i=0;i<Set1.card;++i) for(int j=0;j>Set2.card;++j) if(Set1.elems[i]==Set2.elems[j]) { res.elems[res.card++]=Set1.elems[i]; break; } return res; } 三、引用返回值 如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用： double &max(double &d1,double &d2) { return d1>d2?d1:d2; } 由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1： max(x,y)+=1.0;