zoukankan      html  css  js  c++  java
  • C程序设计语言--指针和引用的区别

    在看了一篇文章以后,http://coolshell.cn/articles/7992.html,说的是C和C++之间的缺陷,当然这篇文章说的非常高深了。所以就找了一些资料,分析了这两者的区别

    在《Effective c++》一书中页介绍了关于指针和引用的区别。

        值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。函数的传值有两种,一个是值传递;一个地指针传递

    一、引用简介

        引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。

    引用的声明方法:类型标识符 &引用名=目标变量名;

    int a; int &ra=a; //定义引用ra,它是变量a的引用,即别名
    说明:

    • &在此不是求地址运算,而是起标识作用。
    • 类型标识符是指目标变量的类型。
    • 声明引用时,必须同时对其进行初始化。
    • 引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,且不能再把该引用名作为其他变量名的别名。ra=1; 等价于 a=1;
    • 声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。故:对引用求地址,就是对目标变量求地址。&ra与&a相等。
    • 不能建立数组的引用。因为数组是一个由若干个元素所组成的集合,所以无法建立一个数组的别名。

    二、引用应用

      1)引用作为参数

        引用的一个重要作用就是作为函数的参数。以前的C语言中函数参数传递是值传递,如果有大块数据作为参数传递的时候,采用的方案往往是指针,因为这样可以避免将整块数据全部压栈,可以提高程序的效率。但是现在(C++中)又增加了一种同样有效率的选择(在某些特殊情况下又是必须的选择),就是引用。例如

    int swap(int &a,int &b);//此处的a b 都是引用

        为在程序中调用该函数,则相应的主调函数的调用点处,直接以变量作为实参进行调用即可,而不需要实参变量有任何的特殊要求。如:对应上面定义的swap函数,相应的主调函数可写为:

    main( )
    {
     int a,b;
     cin>>a>>b; //输入a,b两变量的值
     swap(a,b); //直接以变量a和b作为实参调用swap函数
     cout<<a<< ' ' <<b; //输出结果
    } 

       上述的函数依然可以达到交换两个数字的目的。

    • 传递引用给函数与传递指针的效果是一样的。这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作
    • 使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空间都好。
    • 使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名"的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。而引用更容易使用,更清晰。

    如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。

      2)常引用

        常引用声明方式:const 类型标识符 &引用名=目标变量名;

        用这种方式声明的引用,不能通过引用对目标变量的值进行修改,从而使引用的目标成为const,达到了引用的安全性。

    int a ;
    const int &ra=a;
    ra=1; //错误
    a=1; //正确 

    这不光是让代码更健壮,也有些其它方面的需要。

    假设有如下函数声明:
    
    string foo( );
    void bar(string & s);
    
    那么下面的表达式将是非法的:
    
    bar(foo( ));
    bar("hello world"); 

        原因在于foo( )和"hello world"串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。

    引用型参数应该在能被定义为const的情况下,尽量定义为const 。

      3)引用作为返回值

        要以引用返回函数值,则函数定义时要按以下格式:

    类型标识符 &函数名(形参列表及类型说明)
    {函数体}

    说明:

    • 以引用返回函数值,定义函数时需要在函数名前加&

    • 用引用返回一个函数值的最大好处是,在内存中不产生被返回值的副本。

        以下程序中定义了一个普通的函数fn1(它用返回值的方法返回函数值),另外一个函数fn2,它以引用的方法返回函数值。 

    #include <iostream.h>
    float temp; //定义全局变量temp
    float fn1(float r); //声明函数fn1
    float &fn2(float r); //声明函数fn2
    float fn1(float r) //定义函数fn1,它以返回值的方法返回函数值
    {
     temp=(float)(r*r*3.14);
     return temp;
    }
    float &fn2(float r) //定义函数fn2,它以引用方式返回函数值
    {
     temp=(float)(r*r*3.14);
     return temp;
    }
    void main() //主函数
    {
     float a=fn1(10.0); //第1种情况,系统生成要返回值的副本(即临时变量)
     float &b=fn1(10.0); //第2种情况,可能会出错(不同 C++系统有不同规定)
     //不能从被调函数中返回一个临时变量或局部变量的引用
     float c=fn2(10.0); //第3种情况,系统不生成返回值的副本
     //可以从被调函数中返回一个全局变量的引用
     float &d=fn2(10.0); //第4种情况,系统不生成返回值的副本
     //可以从被调函数中返回一个全局变量的引用
     cout<<a<<c<<d;
    } 

    引用作为返回值,必须遵守以下规则:

    • 不能返回局部变量的引用。这条可以参照Effective C++[1]的Item 31。主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指"的引用,程序会进入未知状态。
    • 不能返回函数内部new分配的内存的引用。这条可以参照Effective C++[1]的Item 31。虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部new分配内存的引用),又面临其它尴尬局面。例如,被函数返回的引用只是作为一个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由new分配)就无法释放,造成memory leak。
    • 可以返回类成员的引用,但最好是const。这条原则可以参照Effective C++[1]的Item 30。主要原因是当对象的属性是与某种业务规则(business rule)相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。
    • 引用与一些操作符的重载:
    • 流操作符<<和>>,这两个操作符常常希望被连续使用,例如:cout << "hello" << endl; 因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括:返回一个流对象和返回一个流对象指针。但是对于返回一个流对象,程序必须重新(拷贝)构造一个新的流对象,也就是说,连续的两个<<操作符实际上是针对不同对象的!这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此,返回一个流对象引用是惟一选择。这个唯一选择很关键,它说明了引用的重要性以及无可替代性,也许这就是C++语言中引入引用这个概念的原因吧。 赋值操作符=。这个操作符象流操作符一样,是可以连续使用的,例如:x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值,以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

    测试用返回引用的函数值作为赋值表达式的左值。

    #include <iostream.h>
    int &put(int n);
    int vals[10];
    int error=-1;
    void main()
    {
    put(0)=10; //以put(0)函数值作为左值,等价于vals[0]=10;
    put(9)=20; //以put(9)函数值作为左值,等价于vals[9]=20;
    cout<<vals[0];
    cout<<vals[9];
    }
    int &put(int n)
    {
    if (n>=0 && n<=9 ) return vals[n];
    else { cout<<"subscript error"; return error; }
    } 

        在另外的一些操作符中,却千万不能返回引用:+-*/ 四则运算符。它们不能返回引用,Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect,因此,它们必须构造一个对象作为返回值,可选的方案包括:返回一个对象、返回一个局部变量的引用,返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则,第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

      4)引用和多态

    引用是除指针外另一个可以产生多态效果的手段。这意味着,一个基类的引用可以指向它的派生类实例。

    class  A;
    class  B:public A{……};
    B  b;
    A  &Ref = b; // 用派生类对象初始化基类对象的引用

    Ref 只能用来访问派生类对象中从基类继承下来的成员,是基类引用指向派生类。如果A类中定义有虚函数,并且在B类中重写了这个虚函数,就可以通过Ref产生多态效果。

    三、引用和指针的区别联系

      1)相同点

        都是地址的概念,指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。

      2)区别

    • 指针是一个实体,而引用仅是个别名;
    • 引用使用时无需解引用(*),指针需要解引用;
    • 引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终” ^_^
    • 引用不能为空,指针可以为空;
    • “sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小;typeid(T) == typeid(T&) 恒为真,sizeof(T) == sizeof(T&) 恒为真,但是当引用作为成员时,其占用空间与指针相同(没找到标准的规定)。
    • 指针和引用的自增(++)运算意义不一样;

      3)在《Effective C++》一书关于指针和引用的区别解释

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

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

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

    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 v(10); // 建立整形向量(vector),大小为10;
    // 向量是一个在标准C库中的一个模板
    v[5] = 10; // 这个被赋值的目标对象就是操作符[]返回的值

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

    *v[5] = 10;

        但是这样会使得v看上去象是一个向量指针。因此你会选择让操作符返回一个引用。
    当你知道你必须指向一个对象并且不想改变其指向时,或者在重载操作符并为防止不必要的语义误解时,你不应该使用指针。而在除此之外的其他情况下,则应使用指针。

    四、引用总结

    • 在引用的使用中,单纯给某个变量取个别名是毫无意义的,引用的目的主要用于在函数参数传递中,解决大块数据或对象的传递效率和空间不如意的问题
    • 用引用传递函数的参数,能保证参数传递中不产生副本,提高传递的效率,且通过const的使用,保证了引用传递的安全性。
    • 引用与指针的区别是,指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。程序中使用指针,程序的可读性差;而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作
    • 使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

    终结小总结:

    从概念上讲。指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

    而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。

    在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的:

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

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

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

    为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别:

    程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。

      上边红色部分的含义可以通过下面的一个函数解释:

     

    void ptrswap(int *a,int *b)
    {
    	int temp=111;
    	a=&temp; //添加上这么一句,是达不到想要的效果的,但是引用是没有问题的
    	temp=*a;
    	*a=*b;
    	*b=temp;
    	printf("%d %d %d
    ",temp,*a,*b);//可以查看下都是什么值
    	}

        在这个函数内重新定义传递参数的指针,也就是重新定向地址,结果达不到想要的结果。

        再给一个函数,使用应用的方式,好好体会,就会清楚红色字的含义

     void swap(int &a,int &b)
    {
        int temp=111;
        //a=temp; 去掉注释,虽说也达不到效果,但是你会明白为什么,也会明白用意的
        temp=a;
        a=b;
        b=temp;    
        }

        虽说也达不到目的,但是会明白用意的。


  • 相关阅读:
    Binary Tree Zigzag Level Order Traversal
    Binary Tree Level Order Traversal
    Symmetric Tree
    Best Time to Buy and Sell Stock II
    Best Time to Buy and Sell Stock
    Triangle
    Populating Next Right Pointers in Each Node II
    Pascal's Triangle II
    Pascal's Triangle
    Populating Next Right Pointers in Each Node
  • 原文地址:https://www.cnblogs.com/keanuyaoo/p/3353206.html
Copyright © 2011-2022 走看看