Java的引用到底是什么?和C/C++的指针有什么区别?

文章目录

  • 1、从操作符说起
    • 1.1、C/C++中指针操作符 & -> * 的作用
    • 1.2、Java中引用操作符 . 的使用
  • 2、指针能干,引用干不了的活~
    • 2.1、指针可以指向任意一个地址,引用只能指向一个对象
    • 2.2、指针可以随意修改所指向地址的数据
  • 3、指针的缺陷
    • 3.1、野指针
    • 3.2、C语言强制类型转换造成的内存误修改
  • 4、总结
    • 4.1、引用能做到的,指针都能**无损**的做到——反之则不行
    • 4.2、指针的灵活带来缺陷,引用的不灵活带来安全
    • 4.3、题外话:C++引用和Java引用的区别

点进这篇文章的朋友们,如果对「指针」没有概念,那么请面壁思过。

你不是一个正统的程序员,你是野路子,是faker,在技术这条路上注定走不远。

Java的引用到底是什么?和C/C++的指针有什么区别?_第1张图片

闲话少述,正文开始。

1、从操作符说起

要看引用和指针的区别,首先要看操作符。

  • 在c/c++中,指针相关的操作符有3个:& -> *
  • 在Java中,引用相关的操作符有1个:.

What,引用就一个操作符???那我们就来看下,操作符各有什么作用

注:指针使用结构体来举例,便于和引用的对象来比较

1.1、C/C++中指针操作符 & -> * 的作用

  • 定义一个结构体和变量

    typedef stuct {
        int sex;
        int age;
    } student_t;
    
    student_t stu1 = {1, 20};
    
  • 操作符 &,将数据地址读取到一个指针

    int* p_addr = &stu1; // 创建一个指针p_addr,p_addr存储了stu1的地址
    
  • 操作符 ->,读/写一个指针所指向结构体地址成员数据

    int age = p_addr->age;
    p_addr->age = 44;
    
  • 操作符 *,读/写一个指针地址数据

    student_t stu2 = *p_addr; // 将p_addr地址的数据读取到stu2
    *p_addr = {2, 8}; // 将数据写入p_addr地址
    

注:c++中也有引用,但不在本文讨论范围内

1.2、Java中引用操作符 . 的使用

  • 定义一个类和对象

    public class Student{
        public Integer sex;
        public Integer age;
        
        Student(Integer s, Integer a) {
            sex = s;
            age = a;
        }
    }
    Student stu1 = new Student(1, 20); // 创建一个引用stu1,stu1中存储的不是对象的数据,而是是对象的地址,也即引用
                                       // stu1存放在stack,对象存放在heap
    
  • 数据地址读取到一个引用

    Student p_addr = stu1; // 创建一个引用p_addr,把stu1中存储的对象的地址,赋给p_addr
    
  • 读/写一个引用所指向对象地址成员数据

    Integer age = stu.age;
    stu.age = 44;
    

    注:Java只有引用,没有指针,而引用弱化了地址和数据的概念,所以程序员们更要深刻理解引用的本质,写出更健壮的代码。

Java的引用到底是什么?和C/C++的指针有什么区别?_第2张图片

如此看来,C/C++指针的操作符 * 能干的活,Java的引用干不了,也就是指针能直接对地址的数据进行读/写,引用则不能

那咱就来看看,具体那些活是指针能干,引用干不了。。。

2、指针能干,引用干不了的活~

2.1、指针可以指向任意一个地址,引用只能指向一个对象

  • 指针可以给用操作符&给其一个数据的地址,也可以直接给其一个地址甚至空地址

    student_t* p_addr = &stu1;
    student_t* p_addr = 0x12000;
    student_t* p_addr = NULL;
    
  • 指针可以对地址进行加减操作,从而修改相邻地址的数据,比如修改一个数组

    int data[4] = {1,2,3,4};
    int* p_addr = data;
    *p_addr = 6;
    p_addr += 1;
    *p_addr = 7;
    p_addr += 1;
    *p_addr = 8;
    p_addr += 1;
    *p_addr = 9;
    // 此时数组内数据为:{6,7,8,9}
    
  • 引用只能指向一个对象,不能直接给其一个地址也不能空引用

    Student stu = new Student();
    Student stu = 0x12000; // 对不起,编译不通过。。。
    
  • 有什么用?

    • 在底层驱动开发时,寄存器的地址是固定的,

      • 想要修改寄存器的数据,需创建一个指针,把寄存器地址赋给指针,然后去修改寄存器。

        // 点亮一个LED
        int* p_led_addr = 0x1233; // LED寄存器地址是0x1233,将其赋给指针p_led_addr
        *p_led_addr = 1; // LED亮
        *p_led_addr = 0; // LED灭
        int state = *p_led_addr; // 读取LED的亮灭状态
        
      • 修改连续地址的多个寄存器

        // 点亮多个LED
        int* p_led_addr = 0x1233; // LED寄存器地址是0x1233,将其赋给指针p_led_addr
        *p_led_addr = 1; // LED亮
        *(p_led_addr+1) = 1; // LED2亮
        *(p_led_addr+2) = 1; // LED3亮
        
    • 显而易见,引用能不能干???干不了!

2.2、指针可以随意修改所指向地址的数据

  • 指针大法

    Student stu1 = new Student(1, 20);
    Student* p_addr = &stu1; // 创建Student类型的指针,指向一个stu1
    *p_addr = 24242; // 将24242写入stu1的地址
    
  • 引用只能修改所指向对象的固定成员,或者通过所指向对象提供的固定方法来修改数据

  • 有什么用?

    • 好像没啥用。。。

3、指针的缺陷

3.1、野指针

  • 定义
    • 指针在创建时,未初始化,此时指向的地址是随机的!此时指针读写,破坏程序运行!
    • 指针所指向地址的数据已经被释放,此时指针读写,则破坏程序运行!
  • 原因
    • 指针可以指向任意一个地址;而引用必须指向一个确定的对象
    • 指针不能自动解除指向;而引用在指向的对象销毁时,会自动解引用
  • 后果
    • 程序奔溃、不能按预期运行、代码漏洞

3.2、C语言强制类型转换造成的内存误修改

  • 定义
    • 将类型A的变量s,强制转换成类型B,然后将其s的地址赋给指向类型B的指针p,对指针p读写
    • 此时类型B的数据结构可能并不兼容类型A,导致对变量s的误修改
  • 原因
    • C语言强制类型转换的不严格检查,过于粗鲁
    • 这是C++为什么要引入四个转换符的原因
  • 后果
    • 程序奔溃、不能按预期运行、代码漏洞

4、总结

4.1、引用能做到的,指针都能无损的做到——反之则不行

  • 指针的操作符 * 能干的活,引用干不了,也就是指针能直接对地址的数据进行读写,引用则不能

  • 指针可以指向任意一个地址(甚至空地址),引用只能指向一个对象(不可空引用)

    • 指针可以对地址进行加减操作,从而修改相邻地址的数据,比如修改一个数组
    • 指针不能自动解除指向;而引用在指向的对象销毁时,会自动解引用
  • 指针可以随意修改所指向地址的数据

    • 引用只能修改所指向对象的固定成员,或者通过所指向对象提供的固定方法来修改数据

4.2、指针的灵活带来缺陷,引用的不灵活带来安全

引用避免了对地址的直接读写,增强了内存操作的规范,从而增强了语言内存安全性,降低了对开发者的要求。

指针和引用,各有各的用途,我们理解本质后,在不同的场景选择合适的工具即可!

Java的引用到底是什么?和C/C++的指针有什么区别?_第3张图片

4.3、题外话:C++引用和Java引用的区别

C++中一个引用指向的地址不会改变,改变的是指向地址的内容,然而Java中引用指向的地址在变!

如果非要对比着看,那么Java中的“引用”倒是和C/C++的指针更像一些,和C++的“引用”很不一样。

java去除指针概念,就用引用罗…

你看 java:

A a = new A(1); 
A b = new A(2); 
b = a; 

没有问题,a 和 b引用同一个对象A(2),原来的A(1)成为没有被引用的对象。 垃圾回收机制会在之后的某个时刻把A(1)干掉。

而C++则不然。C++的引用就语义上说是“别名”【本质是个const指针,又叫指针常量】,而并不是指针的另一种用法:

A a = A(1); 
A b = A(2); 
A& c = b; //c 是 b的别名 
c = a; //并不是 c 引用 a,而是拷贝操作 c.operator= ( a ) 

就语言机制来说,java的引用是用来管理和命名对象;

而,C++的引用机制是很纯粹的,就是别名而已,一旦定义就无法修改,即无法再指向其他变量。

每种语言的特性都是整体的有机部分。

我们知道, java的引用机制是一个很复杂的机制。他必须区分“基本对象”和“复合对象”,你可以想象一下,如果其中没有基本对象,那么我们如何完成对象的复制? 唯一的解决方案是提供两个等于号,或者一律用构造函数… 但是综合来看,他和垃圾回收形成了相当完美的组合方案

而C++ 的引用机制为运算符重载提供了大幅度的支持。C++ 的引用是用类“模拟”基本对象的根本要求。 如果C++使用java那种引用,那么原本漂亮的 operator[]、 proxy class 等就很难实现了。 更进一步, C++ 的运算符重载对 C++ 的模版机制提供了强力的支持

你可能感兴趣的:(后端开发,C++,java,引用,指针,c/c++,引用和指针的区别)