Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1589690
  • 博文数量: 695
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 4027
  • 用 户 组: 普通用户
  • 注册时间: 2013-11-20 21:22
文章分类

全部博文(695)

文章存档

2018年(18)

2017年(74)

2016年(170)

2015年(102)

2014年(276)

2013年(55)

分类: C/C++

2014-08-07 22:26:47

说起形参、指针、引用的区别,

我个人的形象理解就是:

数据在内存中,

就像一颗宝石在一个盒子里,

形参是拿出那颗宝石给人家,

用完就完璧归赵。

指针是传那个盒子给人家,

可以用盒子间接使用到宝石或装其它同类宝石,

但还是要还回来一个盒子的。

引用就是盒子宝石都传给人家,

可以对宝石直接使用或置换,

但最终必须归还同样的盒子和同类的宝石。

确实挺确切的比喻
引用与指针的区别
int n;

int &m = n;

在C++中,多了一个C语言没有的引用声明符&,如上,m就是n的引用,简单的说m就是n的别名,两者在内存中占同样的位置,不对m开辟新的内存空间,对m的任何操作,对n来说是一样的。

对于引用,有以下三条规则:

(1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。
(2)不能有NULL 引用,引用必须与合法的存储单元关联(指针则可以是NULL)。
(3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。

 

假如在一个函数中动态申请内存空间,用指针和用引用作形参会得到不同的结果,如下面的例子:

void fun(int* b){  //用指针做形参
 b = (int*)malloc(sizeof(int)*3);

 for(int i=0; i<3; i++){
  a[i] = i;
 }
}

void fun(int* &b){  //用引用做形参
 b = (int*)malloc(sizeof(int)*3);

 for(int i=0; i<3; i++){
  b[i] = i;
 }
}

如果在main函数中定义了一个int型的空指针并分别作为实参传入,如下:

int main(){
 int *a = NULL;

 fun(a);

 for(int i=0; i<3; i++){
  cout << a[i] << " ";
 }
 cout << "/n";

 return 0;
}

结果用指针的函数会出现内存访问出错,用引用的函数则运行正常并正确输出1 2 3.

这是因为:

1.指针虽然是地址传递,但实际上也是在函数中又定义了一个新的指针让其与传入的指针指向同一地址。但两个指针本身作为变量在内存中的存放地址是不同的,就是说这是两个不同的变量,只是内容(即所指地址)相同。

2.在函数中对新定义的指针动态申请内存,但是当函数结束后,申请的内存的生命周期也就结束了,所以当回到主函数时,作为实参的指针地址和内容都没有变化。仍然是个空指针,对其进行访问自然出现了内存读错误了。

假如在main函数中这样写:

int *a = (int*)malloc(sizeof(int)*3);

就不会出现内存读错误了,但是输出结果还是错误的,道理也是一样的。

3.用引用作为实参传入时,fun函数中的b其实就是主函数中a的别名(或者叫外号),反正就是操作完全相同,地址相同,内容相同的一个变量,所以当fun函数返回时,对b的操作在主函数中对a同样有效。

 

再看一个例子:

int *a = NULL;

char* b = (char*)a;

 

int *a = NULL;

char* &b = (char*)a;

这一次是在编译阶段的区别:

用指针可以通过编译,而用引用则不可以,提示类型转换出错。

 

通过这两个例子可以看出,指针比引用灵活,也更加危险。

 

摘自『高质量c++编程』
条款一:指针与引用的区别
指针与引用看上去完全不同(指针用操作符’*’和’->’,引用使用操作符’.’),但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针,在什么时候使用引用呢?
首 先,要认识到在任何情况下都不能用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象,但是该变量在某些时候也可 能不指向任何对象,这时你应该把变量声明为指针,因为这样你可以赋空值给该变量。相反,如果变量肯定指向一个对象,例如你的设计不允许变量为空,这时你就 可以把变量声明为引用。

 

PS:引用在定义时不可加const,否则编译出错,在形参前面则可以加const以确保在函数中该变量不会被修改。

一、
C++中引用和指针的区别
指针初始化的时候,可以指向一个地址,也可以为空。
引用必须初始化为另一个变量.
 int ival = 1024;
 int *pi  = &ival; // a pointer
 int &rval = ival; // a reference

二、
估计很多人在编写C++程序都或多或少的会用到pointer 和 reference这两种东西,但是他们两者到底有什么样的区别和联系呢,相信大多数人是不太了解的,今天我就两者的区别和联系从实际程序的角度来加以区别。
C/C++中的指针其实就是一个变量,和其他类型的变量是一个样子的,它是一个占用四字节的变量(32位机上),它与其他变量的不同之处就在于它的变量值 是一个内存地址,指向内存的另外一个地方。reference我的理解就是一个别名,它和linux操作系统上的alias是一个样子的。再者,一个 pointer变量可以指向NULL,表示它不指向任何变量地址,但是reference必须在声明的时候就得和一个已经存在的变量相绑定,而且这种绑定 不可改变。下面是我写的一段程序来验证pointer与reference的区别和联系的,希望能对大家理解pointer & reference的区别和联系有所帮助:
#include "stdafx.h"
#include
using namespace std;
int main(int argc, char* argv[])
{
 int ival = 1024;
 int *pi  = &ival; // a pointer
 int &rval = ival; // a reference
 int jval = 4096;
 int xval = 8192;
 cout << "ival = " << ival << "\t";
 cout << "&ival = " << &ival << "\t";
 cout << endl;
 cout << "pi = " << pi << "\t";
 cout << "&pi = " << &pi << "\t";
 cout << "*pi = " << *pi << "\t";
 cout << endl;
 cout << "rval = " << rval << "\t";
 cout << "&rval = " << &rval << "\t";
 cout << endl;
 cout << "jval = " << jval << "\t";
 cout << "&jval = " << &jval << "\t";
 cout << endl;

 // change the values of the reference and the pointer
 pi = &jval;
 rval = jval;

 // print the changes
 cout << endl;
 cout << "ival = " << ival << "\t";
 cout << "&ival = " << &ival << "\t";
 cout << endl;
 cout << "pi = " << pi << "\t";
 cout << "&pi = " << &pi << "\t";
 cout << "*pi = " << *pi << "\t";
 cout << endl;
 cout << "rval = " << rval << "\t";
 cout << "&rval = " << &rval << "\t";
 cout << endl;
 cout << "jval = " << jval << "\t";
 cout << "&jval = " << &jval << "\t";
 cout << endl;

 cout << endl;
 *pi = xval;
 cout << "pi = " << pi << "\t";
 cout << "&pi = " << &pi << "\t";
 cout << "*pi = " << *pi << "\t";
 cout << endl;
 cout << "jval = " << jval << "\t";
 cout << "&jval = " << &jval << "\t";
 cout << endl;

 return 0;
}

一次的执行结果如下:
ival = 1024  &nb

 

sp;  &ival = 0012FF7C
pi = 0012FF7C   &pi = 0012FF78  *pi = 1024
rval = 1024     &rval = 0012FF7C
jval = 4096     &jval = 0012FF70

 

ival = 4096     &ival = 0012FF7C
pi = 0012FF70   &pi = 0012FF78  *pi = 4096
rval = 4096     &rval = 0012FF7C
jval = 4096     &jval = 0012FF70

pi = 0012FF70   &pi = 0012FF78  *pi = 8192
jval = 8192     &jval = 0012FF70

如果有兴趣的话也可以使用其他类型的变量来测试,并且打印出各个变量占用内存的大小,我在这里就不把具体的程序贴出来了。

三、 C++点滴:向函数中传递指针和传递指针的引用的区别:

如果是传递指针,那么回先复制该指针,在函数内部使用的是复制后的指针,这个指针与原来的指针指向相同的地址,如果在函数内部将复制后的指针指向了另外的新的对象,那么不会影响原有的指针;
但是对于传递指针应用,如果将传递进来的指针指向了新的对象,那么原始的指针也就指向了新的对象,这样就会造成内存泄漏,因为原来指针指向的地方已经不能 再引用了,即使没有将传递进来的指针指向新的对象,而是在函数结束的时候释放了指针,那么在函数外部就不能再使用原有的指针了,因为原来的内存已经被释放 了

对象指针和对象引用

指向类的成员的指针

    
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 
    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)<用对象指针调用指向类成员函数指针pfun指向的函数

    }

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

对象指针和对象引用

作函数的参数

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

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

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

    #include 
    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<     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 
    class M
    {
    public:
    M() { x=y=0; }
    M(i
nt i, int j) { x=i; y=j; }
    void copy(M &m);
    void setxy(int i, int j) { x=i; y=j; }
    void print() {cout<     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


阅读(705) | 评论(0) | 转发(0) |
0

上一篇:排序总结

下一篇:new和malloc的区别

给主人留下些什么吧!~~