指针，引用与参数传递

　　今天在编写双链表代码时遇到了这样的困惑：函数参数传递时形参声明为

strunct queue *&Q;

想了半天*&Q的含义，百思不得其解，于是查阅了很多关于指针和引用的资料，总算解决了困惑。

    首先，简单回顾一下指针和引用这两种运算。

int val;
int *pv = &val; //指针声明
int &rv = val; //引用声明

当对引用类型初始化时，表示rv与val相关联，也可以理解为rv是val的别名，rv和val共用一块内存，地址相同，值相同。而&val中&出现在赋值号右边后成为了右值表达式，是一个常量，表示val的地址，这样我们可以把int *pv=&val理解为声明一个int*（指向int类型）的指针pv被赋值为int型变量val的地址。

1. 指针作为函数参数传递时，传递的是地址，对于函数

   void swap(int *lhs,int *rhs){
       int *temp;
       *temp = *lhs;
       *lhs = *rhs;
       *rhs = *temp;
   }

   我们

   int a,b;
   swap(&a,&b);

   这时有lhs=&a;rhs=&b;相当于把a,b的地址作为函数参数进行了传递，进行swap操作，交换的是地址内a,b变量的值，并非地址的交换，所以可以交换成功。如若改成

   void swap(int *lhs,int *rhs){
       int *temp;
       temp = lhs;
       lhs = rhs;
       rhs = temp;
   }

   则不能交换成功，因为传递的是地址（传递的是lhs(int *)，rhs(int *)）函数返回时a，b地址恢复原值。
2. 引用作为函数参数传递时，传递的是变量的引用（别名），而改变别名的变量时原来名字的变量也会改变，对于函数

   void swap(int &lhs,int &rhs){
       int temp;
       temp = lhs;
       lhs = rhs;
       rhs = temp;
   }

   我们

   int a,b;
   swap(a,b)

   lhs,rhs是a,b的引用（别名），我们通过交换lhs和rhs直接交换了a,b的值，函数返回时的lhs和rhs不变
3. 指针的指针作为参数传递，什么情况会会现这种情况呢，就是我们想通过函数改变的变量是指针，比如

   int *pa = &a;
   int *pb = &b;

   我们想交换pa，pb（a，b的地址），这时可以用到指针的指针做参数传递了

   void swap(int **lhs,int **rhs){
       int **temp;
       *temp = *lhs;
       *lhs = *rhs;
       *rhs = *temp;
   }

   我们

   swap(&a,&b)；

   参数传递时

   int* *lhs = &pa; //pa是int *类型
   int* *rhs = &pb; //pb是int *类型

   **lhs的含义就是指向指针的指针的地址变量lhs，&(pa)是对一个int型的指针变量pa求地址，指向int *的指针是int **型的，所以是&a作为参数传递最终改变了pa，pb的值，也就是改变了a，b的地址，交换成功。
4. 最后一种，指针的引用作为参数传递，对于函数

   void swap(int &*lhs,int &*rhs){
       int *temp;
       *temp = *lhs;
       *lhs = *rhs;
       *rhs = *temp;
   }

   我们

   int *pa = &a;
   int *pb = &b;
   swap(pa,pb);

   参数传递时的赋值表达式应为

   & *lhs = pa; //pa为int *类型
   & *rhs = pb; //pb为int *类型

   通过交换*lhs和*rhs直接交换了pa,pb的值，也就是，*pa和*pb的地址没有发生变化，直接改变的pa，pb的值也就是&a，&b，即a，b的地址。

    最后来看这一段程序

struct node
{
       int data;
       struct node *next;
};
 
struct queue
{
       struct node *head;
       struct node *tail;
};
void init(struct queue*& queue)
{
     queue->head = queue->tail = new struct node;
     queue->head->next = NULL;
}

void init(struct queue *&queue);中参数传递采用了*&的方式，也就是传递一个queue *类型的指针变量的引用，那么

 main(int argc, char *argv[])
{
    struct queue *Q;
    init(Q);
}

参数传递时

struct queue* &queue = Q;//Q为queue *类型的引用
queue->head = queue->tail = new struct node;

实际上是为Q->head，Q->tail申请了动态内存空间，Q->head和Q->tail都是struct node*类型，queue->head->next中queue->head与next之间的连接符用->，queue->head->next=NULL;实际是将Q->head->next赋值为空指针，queue->head->next不指向任何结点。既然Q是queue *的，那么我们可以用

void init(struct queue **queue);
struct queue *Q;
init(&Q)

的形式来传递queue *型的参数Q吗，答案是否定的，不修改init的函数体的话，传递时queue是queue**类型的，->head的左端只接受queue*类型，所以编译不能通过。

总结：

1. 参数传递时改变实参值的两种种方式，a.地址传递时改变地址中的值。（指针，指针的指针）b.引用传递时改变别名的值（引用，指针的引用）
2. 参数传递实参应该传递它的指针还是引用呢？这里可以这样考虑，如void func(int *&p),func(?)。应该明确的是int* &p=?应该左右类型匹配，所以?应该是int*型的int* &p=(int*)。而void func(int **p),func(?)中，int* *p=?应该满足?是int*类型的求地址运算，或者int** p=?满足?是int**类型的（但是这样参数传递没有什么太大的意义），所以?是&(int*)型的，int* *p=&(int*)左右匹配。