C语言与java中函数传参比较

不念不忘少年蓝@ 2022-05-17 03:57 376阅读 0赞

## C语言与java中函数传参比较 ##

首先先说结论：**C语言中参数传递有值传递，地址传递，引用传递。但java中的参数传递只有值传递**

### 1.C语言中的参数传递 ###

#### 1>值传递 ####

*  值传递非常好理解，其实就是对函数所传入的实参进行了一次拷贝，虽然传入函数的值与原来的实参是相等的，但是在内存中却占据着不同的地址，所以在函数中对其进行操作也只是在新的内存地址上进行操作，并不会影响到原来的值。
 *  为了更好的理解，我们举个例子

#include<stdio.h>
    
    void test(int a)
    {
        printf("a的值：%d ,",a);
        printf("a的地址： %d\n",&a);
    }
    
    int main()
    {
        int a = 10;
        printf("a的值：%d ,",a);
        printf("a的地址： %d\n",&a);
        test(a);
        return 0;
    }

执行这段代码，我们发现运行结果是这样的：

![image.png][]

清晰的看到通过值传递后函数中的a与实参a在内存中地址不同，所以在函数中对a进行修改是影响不到实际的a的。

--------------------

#### 2>地址传递 ####

*  根据地址传递这个名字我们可以知道在传递参数时是以地址的方式传递的。并且传递的地址也是内存中的一块空间，下面我们来看一下这段代码

#include<stdio.h>
    
    int main()
    {
        int a = 10;
        int* b = &a;
        printf("a的值: %d\n",a);
        printf("a的地址: %d\n",&a);
        printf("b的值: %d\n",b);
        printf("b的地址: %d\n",&b);
        return 0;
    }

跑出来的结果

![image.png][image.png 1]

*  我们在声明指针变量是，一般是 int \*b 这种形式

但是我这里用 int\* b是为了说明：指针其实是一种特殊的数据类型，所以：

int\* b其实就是声明b是一个指针变量

上面的代码中把a的地址赋值给b(指针变量)，而这个指针变量有存放在内存中的某个地方

#include<stdio.h>
    
    void test(int* b)
    {
        int c = 20;
        *b = c; 
    }
    
    int main()
    {
        int a = 10;
        int* b = &a;
        printf("处理前：a的值: %d\n",a);
        printf("处理前：a的地址: %d\n",&a);
        printf("处理前：b的值: %d\n",b);
        printf("处理前：b的地址: %d\n",&b);
    
        test(b); //test(&a);
    
        printf("处理后：a的值: %d\n",a);
        printf("处理后：a的地址: %d\n",&a);
        printf("处理后：b的值: %d\n",b);
        printf("处理后：b的地址: %d\n",&b);
        return 0;
    }

![image.png][image.png 2]

--------------------

### 3>引用传递 ###

很多人分不清地址传递与引用传递，甚至认为两者是相同的，但二者的根本区别就在于，是否开辟了一段新的内存来存放地址

#include<stdio.h>
    
    int main()
    {
        int a = 10;
        int& b = a;
    
        printf("a的值: %d\n",a);
        printf("a的地址: %d\n",&a);
        printf("b的值: %d\n",b);
        printf("b的地址: %d\n",&b);
        return 0;
    }

下面是运行结果：

![image.png][image.png 3]

我们可以看到a和b的值和地址都是相同的，所以调用b，就是调用a，对b赋值就是对a赋值。

#include<stdio.h>
    
    void test(int& b)
    {
        int c = 20;
        b = c;
    } 
    
    int main()
    {
        int a = 10;
        int& b = a;
    
        printf("处理前：a的值: %d\n",a);
        printf("处理前：b的值: %d\n",b);
    
        test(b);    //test(a);
    
        printf("处理后：a的值: %d\n",a);
        printf("处理后：b的值: %d\n",b);
        return 0;
    }

![image.png][image.png 4]

--------------------

三种传参方式比较：(以交换数据为例)

#include<stdio.h>
    
    void swap(int a,int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
    
    void swap2(int& a, int& b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
    
    void swap3(int* a,int* b)
    {
        int temp = *a;
        *a = *b;
        *b = temp;
    }
    
    int main()
    {
        int a = 10;
        int b = 20;
        printf("交换前a = %d, b = %d\n",a,b);
        swap(a,b);
        //swap2(a,b);
        //swap3(&a,&b);
        printf("交换后a = %d, b = %d\n",a,b);
        return 0;
    }

值传递：失败

![image.png][image.png 5]

地址传递：成功

![image.png][image.png 6]

引用传递：成功

![image.png][image.png 7]

--------------------

### Java中的参数传递 ###

*  很多文章中写到java分两种参数传递方式：值传递和引用传递。理由是：java并不是完全的面向对象语言(还有八大基本类型)。针对基本类型，在传递时是值传递。而对于其他的数组类型，类或者接口等引用数据类型，就是引用传递。这篇文章可以说是这种观点的代表：  
    [JAVA中值传递和引用传递的三种情况][JAVA]

但是又有不少文章抨击上面文章的这种观点，并且表明：java中只有一种参数传递方式：值传递

以这篇文章为代表：[Java：传值还是传引用？][Java]

*  在这里我更支持后者的观点，并不是因为我也觉得java中只存在值传递，而是我知道上述前者文章中所说的引用传递并不是我们在上面C语言参数传递中讲的引用传递。接下来我们逐个分析。

#### 1>值传递 ####

因为java中不存在指针的概念，所以我们想像在C语言中那样为交换数据封装一个方法是无法实现的，因为java中并不存在指针类型(既有优点也有缺点)

public class paraTest01 {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            swap(a,b);
            System.out.println("最终 a = " + a);
            System.out.println("最终 b = " + b);
        }
    
        public static void swap(int a, int b){
            int temp = a;
            a = b;
            b = temp;
            System.out.println("方法中：a = " + a);
            System.out.println("方法中：b= " + b);
        }
    }

运行结果：  
![image.png][image.png 8]

这个不需要解释了，应该都懂

--------------------

#### 2> (所谓的)引用传递 ####

之前的第一种观点认为：引用数据类型在进行参数传递的时候是引用传递，接下来我们依次探究

*  数组的参数传递

public class ArrayParaTest {
        public static void main(String[] args) {
            int[] array = {
       1,2,3,4,5};
            change(array);
            System.out.println(array[0]);
        }
    
        public static void change(int[] array){
            array[0] = 0;
        }
    }

![image.png][image.png 9]

结果是数组中的第一个元素被替换了。看到这可能很多人就认为这里就是引用传递，别急，我们继续看

public class paraTest02 {
        public static void main(String[] args) {
            int[] array = {
       1,2,3,4,5};
            change(array);
            for (int temp : array){
                System.out.print(temp + " ");
            }
        }
    
        public static void change(int[] array){
            array = new int[]{
       6, 7, 8, 9, 0};
        }
    }

![image.png][image.png 10]

懵逼了吗？说好的引用传递呢？很多人觉得，只要是一种类型的参数传递，要么就是能改变实际参数，要么就是不能改变实际参数。这怎么既有改变又有没改变呢？

*  下面是另外一个例子

public class ClassPara {
        public static void main(String[] args) {
            Person p = new Person("张三");
            change(p);
            System.out.println(p.getName());
        }
    
        public static void change(Person p){
            p = new Person("李四");
        }
    }
    
    class Person{
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }

![image.png][image.png 11]

原对象中的属性没有发生变化，但如果是下面的例子

public class ClassPara {
        public static void main(String[] args) {
            Person p = new Person("张三");
            change(p);
            System.out.println(p.getName());
        }
    
        public static void change(Person p){
            p.setName("李四");
        }
    }
    
    class Person{
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    }

这次的运行结果就是这样的：

![image.png][image.png 12]

##### 综上我们可以总结出这样通俗的结论：如果在方法参数中传递了引用数据类型后，如果是对该引用自身(自身的方法或属性)进行操作，那么实际的参数也伴随着发生了变化。但如果是在方法中给该引用重新赋值了一个新的对象(关键字 new 所创建的)，那么该引用就指向了另一个对象的引用，而不是改变原引用中的属性 #####

--------------------

### String类： ###

*  String类是比较特殊的一类引用数据类型，所以我们单独把它拿出来说，我们先看String类的jdk源码中有这么一句：
 *  “their values cannot be changed after they are created”
 *  并且还有一段：
 *  String str = “abc”;  
    等效于：  
    char data\[\] = \{‘a’, ‘b’, ‘c’\};  
    String str = new String(data);

其实就是对String类的任何修改 就是新创建了一个对象，并把新的对象的引用赋给之前的对象的引用。

所以下面这个例子也就可以理解了

public class StringParaTest {
        public static void main(String[] args) {
            String str = "AAA";
            change(str);
            System.out.println(str);
        }
    
        public static void change(String str){
            str = "abc";
            //等价于：
            // char data = {'a'.'b','c'};
            //str = new String(data);
        }
    }

运行结果我们可以猜出来：

![image.png][image.png 13]

实质上在方法内还是只改变了对象的引用，所以没有什么卵用。

--------------------

#### 综上，其实我们所认为的java中的引用传递，其实只是传递了对象的引用的值，之所以可以改变实际参数是因为我们根据引用值找到了实际对象并对其进行了修改。但是如果创建新的对象并赋值给该对象引用。就只是改变了这个引用的指向，而传入方法的引用只是原引用的一份拷贝，所以完全不会影响到实际的参数值。 ####

#### \- 一个方法不能修改一个基本数据类型的参数(数值型或布尔型)。一个方法可以改变一个对象参数的状态。一个方法不能让对象参数引用一个新的对象。 ####

[image.png]: /images/20220517/10429f5f18bd41b6814987bb2f75d873.png
[image.png 1]: /images/20220517/e6f469e6e481488e9f9c58233963cfef.png
[image.png 2]: /images/20220517/d72b0f62886b44978cd8e6aa649fa22c.png
[image.png 3]: /images/20220517/e66cf887de7a4f22950810e63c8a0b16.png
[image.png 4]: /images/20220517/11aacae0aa394fdf9543f6151d2f95d4.png
[image.png 5]: /images/20220517/c83424ec4d8f45a79f62ee22b1fd8330.png
[image.png 6]: /images/20220517/90a500313dfa419e86d2f7200c3a6eee.png
[image.png 7]: /images/20220517/6812939b12944de0a062ed11422ea175.png
[JAVA]: https://blog.csdn.net/zhzhao999/article/details/53449504
[Java]: https://www.cnblogs.com/chen-kh/p/6696303.html
[image.png 8]: /images/20220517/2d0439ed0f4542639cf631f71be3db7b.png
[image.png 9]: /images/20220517/8cad5d0d53a4419aa04a4d34f6ba8a94.png
[image.png 10]: /images/20220517/77b580d3514044deb24087ec46a93f7e.png
[image.png 11]: /images/20220517/4a0b04a7f3d046fb9b397125c3229bc5.png
[image.png 12]: /images/20220517/988e8ac041bf4e54b6a9188337778ace.png
[image.png 13]: /images/20220517/4e4add95dd0442fea2bbb26daf4d8da2.png