浅析指针（pointer）与引用（reference）

在c++函数中，形式参数用引用和用指针都可以起到在被调用函数中改变调用函数的变量的作用。什么时候用引用作参数?什么时候用指针作参数呢

void function (int *ptr); void function(int &ref);

没有 特定的规定。。学的 久了，就 会习惯什么时候用指针什么时候用引用了!

从概念上讲。指针从本质上讲就是存放变量地址的一个变量，在逻辑上是独立的，它可以被改变，包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。而引用是一个别名，它在逻辑上不是独立的，它的存在具有依附性，所以引用必须在一开始就被初始化，而且其引用的对象在其整个生命周期中是不能被改变的（自始至终只能依附于同一个变量）。

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

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

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

在传参的时候，使用指针传参，编译器需要给指针另行分配存储单元，存储一个该指针的副本，在函数中对这个副本进行操作；使用引用传参，编译器就不需要分配存储空间和保存副本了，函数将直接对实参进行操作。所以使用引用使得程序的效率更高。

引用之间的赋值和指针之间的赋值不同。
指针：
Int ival= 1024，ival2 = 2048；
Int *pi = &ival, *pi2 = &ival2;
这时候写 pi = pi2；//pi指向的对象ival并没有改变，实际上pi被赋值 为pi2所指向的对象。 
引用：
Int  &ri = ival，&ri2 = ival2；
这时候写 ri = ri2；//改变的是ival，而不是引用本身ri。赋值之后，两个引用还是指向各自的原来对象。

★相同点：

●都是地址的概念；

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

★不同点：

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

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

●引用没有const，指针有const，const的指针不可变；

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

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

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

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

C++中尽量用引用。个人觉得所有的引用都可以用指针，但指针比引用容易出错。
   
引用当然更直观更直接，做参数时，如果在函数内不刻意要用指针的那些副作用（如越界访问，动态定向什么的），引用可以代替指针。
    C++
中一般都用引用就可以了 ... C 中没有引用，就使用指针 ....

举例如下：
1 使用指针传递参数时：
void function (int *ptr) { 函数体;}
调用该函数时
main()
{ int p; function (&p); }
2 使用引用传递参数时：
void function(int &ref) { 函数体;}
调用该函数时
main()
{ int p; function (p); }
由此可见，使用引用比使用指针传递参数函数调用时更简单，引用和指针功能大体相同，但是有空间分配时建议最好使用指针，因为在释放空间时，

对指针只需要delete就行了，而引用是不能删除空间的，引用必须指向一个存在的对象。

对象指针和对象引用

指向类的成员的指针

在C++中，可以说明指向类的数据成员和成员函数的指针。

指向数据成员的指针格式如下：

<类型说明符><类名>::*<指针名>

指向成员函数的指针格式如下：

<类型说明符>(<类名>::*<指针名>)(<参数表>)

例如，设有如下一个类A：

class A
    {
    public:
        int fun (int b) { return a*c+b; }
        A(int i) { a=i; }
        int c;
    private:
         int a;
    };

定义一个指向类A的数据成员c的指针pc，其格式如下：
    int A:: *pc = &A::c;
    再定义一个指向类A的成员函数fun的指针pfun，其格式如下：
    int (A:: *pfun)(int) = A::fun;

由于类不是运行时存在的对象。因此，在使用这类指针时，需要首先指定A类的一个对象，然后，通过对象来引用指针所指向的成员。例如，给pc指针所指向的数据成员c赋值8，可以表示如下：

A a;
    a.*pc = 8;

其中，运算符.*是用来对指向类成员的指针来操作该类的对象的。
    如果使用指向对象的指针来对指向类成员的指针进行操作时，使用运算符->*。例如：
    A *p = &a;    //a是类A的一个对象，p是指向对象a的指针。
    p ->* pc = 8;
    让我们再看看指向一般函数的指针的定义格式：

<类型说明符>*<指向函数指针名>(<参数表>)

关于给指向函数的指针赋值的格式如下：

<指向函数的指针名>=<函数名>

关于在程序中，使用指向函数的指针调用函数的格式如下：

(*<指向函数的指针名>)(<实参表>)

如果是指向类的成员函数的指针还应加上相应的对象名和对象成员运算符。

下面给出一个使用指向类成员指针的例子：

#include <iostream.h>
    class A
    {
    public:
    A(int i) { a=i; }
    int fun(int b) { return a*c+b; }
    int c;
    private:
    int a;
    };

void main()
    {
    A x(8);        //定义类A的一个对象x
    int A::*pc;    //定义一个指向类数据成员的指针pc
    pc=&A::c;    //给指针pc赋值
    x.*pc=3;    //用指针方式给类成员c赋值为3
    int (A::*pfun)(int);    //定义一个指向类成员函数的指针pfun
    pfun=A::fun;        //给指针pfun赋值
    A *p=&x;        //定义一个对象指针p，并赋初值为x
    cout<<(p->*pfun)(5)<<endl;    //用对象指针调用指向类成员函数指针pfun指向的函数
    }

以上程序定义了好几个指针，虽然它们都是指针，但是所指向的对象是不同的。p是指向类的对象；pc是指向类的数据成员；pfun是指向类的成员函数。因此它们的值也是不相同的。

对象指针和对象引用作函数的参数

    1. 对象指针作函数的参数

使用对象指针作为函数参数要经使用对象作函数参数更普遍一些。因为使用对象指针作函数参数有如下两点好处：
    (1) 实现传址调用。可在被调用函数中改变调用函数的参数对象的值，实现函数之间的信息传递。
    (2) 使用对象指针实参仅将对象的地址值传给形参，而不进行副本的拷贝，这样可以提高运行效率，减少时空开销。

当形参是指向对象指针时，调用函数的对应实参应该是某个对象的地址值，一般使用&后加对象名。下面举一例子说明对象指针作函数参数。

#include <iostream.h>
    class M
    {
    public:
        M() { x=y=0; }
        M(int i, int j) { x=i; y=j; }
        void copy(M *m);
        void setxy(int i, int j) { x=i; y=j; }
        void print() { cout<<x<<","<<y<<endl; }
    private:
        int x, y;
    };

void M::copy(M *m)
    {
    x=m->x;
    y=m->y;
    }

void fun(M m1, M *m2);
    void main()
    {
    M p(5, 7), q;
    q.copy(&p);
    fun(p, &q);
    p.print();
    q.print();
    }

void fun(M m1, M *m2)
    {
    m1.setxy(12, 15);
    m2->setxy(22,25);
    }

输出结果为：
    5,7
    22,25
    从输出结果可以看出，当在被调用函数fun中，改变了对象的数据成员值[m1.setxy(12, 15)]和指向对象指针的数据成员值[m2->setxy(22, 25)]以后，可以看到只有指向对象指针作参数所指向的对象被改变了，而另一个对象作参数，形参对象值改变了，可实参对象值并没有改变。因此输出上述结果。

2. 对象引用作函数参数

在实际中，使用对象引用作函数参数要比使用对象指针作函数更普遍，这是因为使用对象引用作函数参数具有用对象指针作函数参数的优点，而用对象引用作函数参数将更简单，更直接。所以，在C++编程中，人们喜欢用对象引用作函数参数。现举一例子说明对象引用作函数参数的格式。

#include <iostream.h>
    class M
    {
    public:
    M() { x=y=0; }
    M(int i, int j) { x=i; y=j; }
    void copy(M &m);
    void setxy(int i, int j) { x=i; y=j; }
    void print() {cout<<x<<","<<y<<endl; }
    private:
    int x, y;
    };

void M::copy(M &m)
    {
    x=m.x;
    x=m.y;
    }

void fun(M m1, M &m2);

void main()
    {
    M p(5, 7), q;
    q.copy(p);
    fun(p, q);
    p.print();
    q.print();
    }

void fun(M m1, M &m2)
    {
    m1.setxy(12, 15);
    m2.setxy(22, 25);
    }

该例子与上面的例子输出相同的结果，只是调用时的参数不一样。

3、this指针

this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象,也就是要操作该成员函数的对象。

当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this来标识调用该成员函数的对象。下面举一例子说明this指针的应用。

#include <iostream.h>
    class A
    {
    public:
    A() { a=b=0; }
    A(int i, int j) { a=i; b=j; }
    void copy(A &aa);    //对象引用作函数参数
    void print() {cout<<a<<","<<b<<endl; }
    private:
    int a, b;
    };

void A::copy(A &aa)
    {
    if (this == &aa) return;    //这个this是操作该成员函数的对象的地址，在这里是对象a1的地址
    *this = aa;    //*this是操作该成员函数的对象，在这里是对象a1。
            //此语句是对象aa赋给a1，也就是aa具有的数据成员的值赋给a1的数据成员
    }

void main()
    {
    A a1, a2(3, 4);
    a1.copy(a2);
    a1.print();
    }
    运行结果：
    3, 4

指针与引用看上去完全不同（指针用操作符’*’和’->’，引用使用操作符’.’），但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针，在什么时候使用引用呢？

　 　首先，要认识到在任何情况下都不能用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象，但是该变量在某些时候 也可能不指向任何对象，这时你应该把变量声明为指针，因为这样你可以赋空值给该变量。相反，如果变量肯定指向一个对象，例如你的设计不允许变量为空，这时 你就可以把变量声明为引用。

　“但是，请等一下”，你怀疑地问，“这样的代码会产生什么样的后果？”

　　char *pc = 0; // 设置指针为空值

　　char& rc = *pc; // 让引用指向空值

　 　这是非常有害的，毫无疑问。结果将是不确定的（编译器能产生一些输出，导致任何事情都有可能发生），应该躲开写出这样代码的人除非他们同意改正错误。如 果你担心这样的代码会出现在你的软件里，那么你最好完全避免使用引用，要不然就去让更优秀的程序员去做。我们以后将忽略一个引用指向空值的可能性。

　　因为引用肯定会指向一个对象，在C里，引用应被初始化。

　　string& rs; // 错误，引用必须被初始化

　　string s("xyzzy");

　　string& rs = s; // 正确，rs指向s指针没有这样的限制。

　　string *ps; // 未初始化的指针，合法但危险

　　不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。

　　void printDouble(const double& rd)

　　{

　　　cout << rd; // 不需要测试rd,它

　　} 　　　　　 // 肯定指向一个double值

　　相反，指针则应该总是被测试，防止其为空：

　　void printDouble(const double *pd)

　　{

　　　if (pd)

　　　{// 检查是否为NULL

　　　　cout << *pd;

　　　}

　　}

　　指针与引用的另一个重要的不同是指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变。

　　string s1("Nancy");

　　string s2("Clancy");

string& rs = s1; // rs 引用 s1

　　string *ps = &s1; // ps 指向 s1

　　rs = s2; // rs 仍旧引用s1

　　        // 但是 s1的值现在是"Clancy"

ps = &s2; // ps 现在指向 s2;// s1 没有改变

　 　总的来说，在以下情况下你应该使用指针，一是你考虑到存在不指向任何对象的可能（在这种情况下，你能够设置指针为空），二是你需要能够在不同的时刻指向 不同的对象（在这种情况下，你能改变指针的指向）。如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，那么你应该使用引用。

　　还有一种情况，就是当你重载某个操作符时，你应该使用引用。最普通的例子是操作符[]。这个操作符典型的用法是返回一个目标对象，其能被赋值。

　　vector<int> v(10); //建立整形向量（vector），大小为10

　　                  //向量是一个在标准C库中的一个模板(见条款35)

　　v[5] = 10; // 这个被赋值的目标对象就是操作符[]返回的值

　　如果操作符[]返回一个指针，那么后一个语句就得这样写：

　　*v[5] = 10;

　　但是这样会使得v看上去象是一个向量指针。因此你会选择让操作符返回一个引用。（这有一个有趣的例外，参见条款30）

　　当你知道你必须指向一个对象并且不想改变其指向时，或者在重载操作符并为防止不必要的语义误解时，你不应该使用指针。而在除此之外的其他情况下，则应使用指针。