C++的函数的传值调用、指针调用、引用调用的联系区别

心已赠人 2022-05-04 02:26 232阅读 0赞

当调用函数时，有两种向函数传递参数的方式：

<table> 
 <tbody> 
  <tr> 
   <th>调用类型</th> 
   <th>描述</th> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-function-call-by-value.html" rel="nofollow">传值调用</a></td> 
   <td>该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-function-call-by-pointer.html" rel="nofollow">指针调用</a></td> 
   <td>该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。</td> 
  </tr> 
  <tr> 
   <td><a href="http://www.runoob.com/cplusplus/cpp-function-call-by-reference.html" rel="nofollow">引用调用</a></td> 
   <td>该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。</td> 
  </tr> 
 </tbody> 
</table>

默认情况下，C++ 使用**传值调用**来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的参数。之前提到的实例，调用 max() 函数时，使用了相同的方法。

# C++ 传值调用 #

[![C++ 函数][C_] C++ 函数][C_ _C_ C_]

向函数传递参数的**传值调用**方法，把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。

默认情况下，C++ 使用*传值调用*方法来传递参数。一般来说，这意味着函数内的代码不会改变用于调用函数的实际参数。函数 **swap()** 定义如下：

// 函数定义
    void swap(int x, int y)
    {
       int temp;
     
       temp = x; /* 保存 x 的值 */
       x = y;    /* 把 y 赋值给 x */
       y = temp; /* 把 x 赋值给 y */
      
       return;
    }

现在，让我们通过传递实际参数来调用函数 **swap()**：

## 实例 ##

#include <iostream>
    using namespace std;
     
    // 函数声明
    void swap(int x, int y);
     
    int main ()
    {
       // 局部变量声明
       int a = 100;
       int b = 200;
     
       cout << "交换前，a 的值：" << a << endl;
       cout << "交换前，b 的值：" << b << endl;
     
       // 调用函数来交换值
       swap(a, b);
     
       cout << "交换后，a 的值：" << a << endl;
       cout << "交换后，b 的值：" << b << endl;
     
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

交换前，a 的值： 100
    交换前，b 的值： 200
    交换后，a 的值： 100
    交换后，b 的值： 200

上面的实例表明了，虽然在函数内改变了 a 和 b 的值，但是实际上 a 和 b 的值没有发生变化。

# C++ 指针调用 #

[![C++ 函数][C_] C++ 函数][C_ _C_ C_]

向函数传递参数的**指针调用**方法，把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

按指针传递值，参数指针被传递给函数，就像传递其他值给函数一样。因此相应地，在下面的函数 **swap()** 中，您需要声明函数参数为指针类型，该函数用于交换参数所指向的两个整数变量的值。

// 函数定义
    void swap(int *x, int *y)
    {
       int temp;
       temp = *x;    /* 保存地址 x 的值 */
       *x = *y;        /* 把 y 赋值给 x */
       *y = temp;    /* 把 x 赋值给 y */
      
       return;
    }

如需了解 C++ 中指针的更多细节，请访问 [C++ 指针][C_ 1] 章节。

现在，让我们通过指针传值来调用函数 **swap()**：

#include <iostream>
    using namespace std;
    
    // 函数声明
    void swap(int *x, int *y);
    
    int main ()
    {
       // 局部变量声明
       int a = 100;
       int b = 200;
     
       cout << "交换前，a 的值：" << a << endl;
       cout << "交换前，b 的值：" << b << endl;
    
       /* 调用函数来交换值
        * &a 表示指向 a 的指针，即变量 a 的地址 
        * &b 表示指向 b 的指针，即变量 b 的地址 
        */
       swap(&a, &b);
    
       cout << "交换后，a 的值：" << a << endl;
       cout << "交换后，b 的值：" << b << endl;
     
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

交换前，a 的值： 100
    交换前，b 的值： 200
    交换后，a 的值： 200
    交换后，b 的值： 100

# C++ 引用调用 #

[![C++ 函数][C_] C++ 函数][C_ _C_ C_]

向函数传递参数的**引用调用**方法，把引用的地址复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

按引用传递值，参数引用被传递给函数，就像传递其他值给函数一样。因此相应地，在下面的函数 **swap()** 中，您需要声明函数参数为引用类型，该函数用于交换参数所指向的两个整数变量的值。

// 函数定义
    void swap(int &x, int &y)
    {
       int temp;
       temp = x; /* 保存地址 x 的值 */
       x = y;    /* 把 y 赋值给 x */
       y = temp; /* 把 x 赋值给 y  */
      
       return;
    }

现在，让我们通过引用传值来调用函数 **swap()**：

#include <iostream>
    using namespace std;
    
    // 函数声明
    void swap(int &x, int &y);
    
    int main ()
    {
       // 局部变量声明
       int a = 100;
       int b = 200;
     
       cout << "交换前，a 的值：" << a << endl;
       cout << "交换前，b 的值：" << b << endl;
    
       /* 调用函数来交换值 */
       swap(a, b);
    
       cout << "交换后，a 的值：" << a << endl;
       cout << "交换后，b 的值：" << b << endl;
     
       return 0;
    }

当上面的代码被编译和执行时，它会产生下列结果：

交换前，a 的值： 100
    交换前，b 的值： 200
    交换后，a 的值： 200
    交换后，b 的值： 100

[C_]: http://www.runoob.com/images/up.gif
[C_ _C_ C_]: /images/20220504/b9acd0b371af4876ab106a8bc473e504.png
[C_ 1]: http://www.runoob.com/cplusplus/cpp-pointers.html