C++中指针传递与引用传递-yiteyi-C++库

在C++中，我们可以通过指针或引用将参数传递给函数。在这两种情况下，我们得到相同的结果。那么，问题是什么 C++中指针传递与引用传递的区别

null

首先让我们理解C++中指针传递和引用传递的含义： 1）通过指针传递： 在这里，变量的内存位置被传递给函数中的参数，然后执行操作。

CPP

                         // C++ program to swap two numbers using                       
                         // pass by pointer                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         void                                     swap(                                     int                                     *x,                                     int                                     *y)                       
                         {                       
                                                 int                                     z = *x;                       
                                                 *x = *y;                       
                                                 *y = z;                       
                         }                       
           
                         // Driver Code                       
                         int                                     main()                       
                         {                       
                                                 int                                     a = 45, b = 35;                       
                                                 cout <<                                     "Before Swap"                                     ;                       
                                                 cout <<                                     "a = "                                     << a <<                                     " b = "                                     << b <<                                     ""                                     ;                       
           
                                                 swap(&a, &b);                       
           
                                                 cout <<                                     "After Swap with pass by pointer"                                     ;                       
                                                 cout <<                                     "a = "                                     << a <<                                     " b = "                                     << b <<                                     ""                                     ;                       
                         }                       

输出

Before Swapa = 45 b = 35After Swap with pass by pointera = 35 b = 45

2）参考传递： 它允许函数修改变量，而无需创建变量的副本。我们必须声明引用变量。传递的变量和参数的内存位置相同，因此，对参数的任何更改也会反映在变量中。

CPP

                         // C++ program to swap two numbers using                       
                         // pass by reference                       
           
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
                         void                                     swap(                                     int                                     & x,                                     int                                     & y)                       
                         {                       
                                                 int                                     z = x;                       
                                                 x = y;                       
                                                 y = z;                       
                         }                       
           
                         int                                     main()                       
                         {                       
                                                 int                                     a = 45, b = 35;                       
                                                 cout <<                                     "Before Swap"                                     ;                       
                                                 cout <<                                     "a = "                                     << a <<                                     " b = "                                     << b <<                                     ""                                     ;                       
           
                                                 swap(a, b);                       
           
                                                 cout <<                                     "After Swap with pass by reference"                                     ;                       
                                                 cout <<                                     "a = "                                     << a <<                                     " b = "                                     << b <<                                     ""                                     ;                       
                         }                       

输出

Before Swapa = 45 b = 35After Swap with pass by referencea = 35 b = 45

参考变量和指针变量之间的差异： 引用是同一个对象，只是名称不同，引用必须引用对象。因为引用不能为NULL，所以使用它们更安全。

指针可以重新分配，而引用不能，并且只能在初始化时分配。
指针可以直接赋值为NULL，而引用不能。
指针可以遍历数组，我们可以使用递增/递减运算符转到指针指向的下一个/上一个项。
指针是保存内存地址的变量。引用与它引用的项具有相同的内存地址。
指向类/结构的指针使用“->”（箭头运算符）访问其成员，而引用使用“.”（点运算符）
指针需要用*解除引用才能访问它所指向的内存位置，而引用可以直接使用。

以下示例演示了这些区别：

CPP

                         // C++ program to demonstrate differences                       
                         // between pointer and reference                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         struct                                     demo {                       
                                                 int                                     a;                       
                         };                       
           
                         int                                     main()                       
                         {                       
                                                 int                                     x = 5;                       
                                                 int                                     y = 6;                       
                                                 demo d;                       
           
                                                 int                                     * p;                       
                                                 p = &x;                       
                                                 p = &y;                                     // 1. Pointer reintialization allowed                       
           
                                                 int                                     & r = x;                       
                                                 // &r = y;                 // 1. Compile Error                       
           
                                                 r = y;                                     // 1. x value becomes 6                       
           
                                                 p = NULL;                       
                                                 // &r = NULL;             // 2. Compile Error                       
           
                                                 // 3. Points to next memory location                       
                                                 p++;                       
           
                                                 // 3. x values becomes 7                       
                                                 r++;                       
           
                                                 cout << &p <<                                     " "                                     << &x <<                                     ''                                     ;                                     // 4. Different address                       
                                                 cout << &r <<                                     " "                                     << &x <<                                     ''                                     ;                                     // 4. Same address                       
           
                                                 demo* q = &d;                       
                                                 demo& qq = d;                       
           
                                                 q->a = 8;                       
                                                 // q.a = 8;                 // 5. Compile Error                       
                                                 qq.a = 8;                       
                                                 // qq->a = 8;             // 5. Compile Error                       
           
                                                 // 6. Prints the address                       
                                                 cout << p <<                                     ''                                     ;                       
           
                                                 // 6. Print the value of x                       
                                                 cout << r <<                                     ''                                     ;                       
           
                                                 return                                     0;                       
                         }                       

输出

0x7ffc7ed95828 0x7ffc7ed958200x7ffc7ed95820 0x7ffc7ed958200x47

在C++中，指针通过VS传递的首选项是什么？

每当我们不需要“重置”时，引用通常优先于指针。
全面的 尽可能使用引用，必要时使用指针 但是，如果我们要编写C和C++编译器编译的C代码，就必须限制使用指针。

本文由 罗希特·卡斯尔 。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请发表评论。

文章版权归作者所有，未经允许请勿转载。

THE END