参考自以下内容，侵删：

不同之处

不存在空引用。引用必须连接到一块合法的内存。存在空指针NULL。
一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
引用必须在创建时被初始化。指针可以在任何时间被初始化。

函数参数传递

值传递传递的是变量的拷贝。
引用传递传递的是同一个变量。
指针传递传递的是变量的地址的拷贝（本质上也是值传递）。

可以看到值传递和指针传递都会发生拷贝，而引用传递避免了拷贝。

复杂一点：

#include "stdio.h"

void f1( int*&p){  
  printf("\n---f1---\n");
  printf("指针p的地址：%p",&p);  
  printf("\n指针p的值%p",p);  
  printf("\n指针p指向的内容：%x\n",*p);  
  *p=0xff;  
}  

void f2( int* p){  
  printf("\n---f2---\n");
  printf("指针p的地址：%p",&p);  
  printf("\n指针p的值%p",p);  
  printf("\n指针p指向的内容：%x\n",*p);  
  *p=0xff;  
} 

int main()  
{  
  int a=0x10;  
  printf("a的地址：%p\n",&a);  
  printf("a的值：%x\n\n",a);  
  int *b=&a;  
  printf("指针b的地址：%p\n",&b);  
  printf("指针b的值：%p\n",b);  
  printf("指针b指向的内容：%x\n",*b);  
  f1(b);  
  printf("\n试图在函数f1中改变a的之后a的值：%x\n",a);  

  a = 0x10;
  f2(b);  
  printf("\n试图在函数f2中改变a的之后a的值：%x\n",a); 
}

执行的结果是：

a的地址：0x7fff50d8bbac
a的值：10

指针b的地址：0x7fff50d8bba0
指针b的值：0x7fff50d8bbac
指针b指向的内容：10

---f1---
指针p的地址：0x7fff50d8bba0
指针p的值0x7fff50d8bbac
指针p指向的内容：10

试图在函数f1中改变a的之后a的值：ff

---f2---
指针p的地址：0x7fff50d8bb68
指针p的值0x7fff50d8bbac
指针p指向的内容：10

试图在函数f2中改变a的之后a的值：ff

虽然f1和f2都可以改变a的值。但是，函数f1由于传入的是指针的引用，所以从b到p没有发生指针的复制。而f2由于传入的是指针本身，所以还是会复制指针（b和p的地址不一样）。

举个栗子

#include "stdio.h"
class A{
public:
  A(int value):m_value(value)
  {}
  int m_value;
};

void f(A /*这里写什么？*/_a) { //这里参数传递使用什么呢？
  // 我们希望可以创建在main函数中声明的实例 a
    _a = new A(5);
    printf("%d\n", _a->m_value);
}
int main() {
  A* a;
  f(a); //传入指针
  printf("%d\n", a->m_value);
}

(A* _a)可否？答案是：不行！因为这时候指针_a是a的复制，两个指针的地址是不同:

5
-125990072

(A*& _a)可否？答案是：可以！因为这时候传入的是指针的引用，即指针本身，所以没有问题。

5
5

从上面的例子发现，可以在主函数中声明一个实例的空指针，然后通过其他函数来对它进行创建和销毁。（有什么用？）

为什么使用指针/引用？

参数传递中，如果参数是大型对象，引用和指针相比于直接传值有效率优势（但引用和指针的优劣我不太明白，个人感觉指针只是复制了一遍指针的大小（32位机子就是4个字节的空间），还可以接受吧……）：

引用不产生副本
指针只复制指针本身，而不是整个对象

另外，因为函数只能返回一个数值。如果使用引用或指针作为参数，则可以在函数中改变多个变量（可变参数）。

函数参数传递用指针？还是引用？

只能使用引用

有些函数只能传递引用，如重载运算符。因为指针的运算符是语言预定义好的，无法重载。比如：

const maxCard=100; 
Class Set 
{
  int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。 
  int card; // 集合中元素的个数。 
  public:
  Set () {card=0;} //构造函数
  friend Set operator * (Set ,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;
}

其他情况下的一些准则

来自这里:
相比起引用，指针有这些特点：

指针变量可以被重复赋值或更改（引用则不行，一经赋值不能再改）
指针变量可以为空（可以传入一个空的指针）

里面还有于洋的神的回答，因为不让转载，就不贴了，想看再点链接吧。大概就是想要改变变量的数值，使用指针；如果传入不可变的变量，用const+引用。

函数返回引用

通过使用引用来替代指针，会使Cpp程序更容易阅读和维护。Cpp函数可以返回一个引用，方式与返回一个指针类似。

当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。

double &max(double &d1,double &d2)
{
  return d1>d2?d1:d2;
}

由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1：
max(x,y)+=1.0;

C++中的引用和指针