精华内容
下载资源
问答
  • 形参影响实参
    千次阅读
    2018-04-24 22:53:00

    a当参数类型是基本数据类型时,形参的改变不会影响到实参;

    b当参数类型是引用数据类型时,若修改形参指向的内容会影响到实参,因为形参和实参指向的是同一块区域

    c当参数类型时引用数据类型时,若先修改形参的指向后再修改形参指向的内容则不会影响到实参的数值,因为此时二者指向的区域是不同的.

    例如

    public class Test01{

        public static void main(String[] args){

            int num = 10;

            Test01 te = new Test01();

            te.show(num);

            System.out.println("main函数中num的值:"+num);

            int[] arr = {1,2,3};

            te.test(arr);

            System.out.println("main函数中数组的第一个值是:"+arr[0]);//结果为1000

        }

        public void show(int num){

            num = 200;

            System.out.println("show方法中num的值:"+num);

        }

        public void test(int[] arr){

        //arr = new arr[4];若加上这一句,则main函数中的数组不再受到影响,因为test中的数组改变了指向

        arr[0]=1000;

        System.out.println("test方法中数组的第一个值是:"+arr[0]);//结果为1000

        }

    }

    更多相关内容
  • 自定义一个测试函数,通过对比形参实参的ID来研究修改形参实参影响。 def test(a) : print("a =",a,id(a)) c = 20 test(c) print("c =",c,id(c)) a = 20 140707504189792 c = 20 140707504189792 传参后a...

    自定义一个测试函数,通过对比形参和实参的ID来研究修改形参对实参的影响。

    def test(a) :
    	
    	print("a =",a,id(a))
    c = 20
    test(c)
    print("c =",c,id(c))
    
    a = 20 140707504189792
    c = 20 140707504189792
    

    传参后a和c的id相同,说明a和c指向同一对象。
    接下来对a进行重新赋值。

    def test(a) :
    	a = 10
    	print("a =",a,id(a))
    c = 20
    test(c)
    print("c =",c,id(c))
    
    a = 10 140707504189472
    c = 20 140707504189792
    

    a的值和id已经发生了改变,但是c没有发生变化,说明对a重新赋值过程中,系统新建了一个对象,a指向了新的对象,且对c没有产生影响。

    接下来测试传列表的情况。

    def test(a) :
    	
    	print("a =",a,id(a))
    c = [1,2,3]
    test(c)
    print("c =",c,id(c))
    
    a = [1, 2, 3] 3051365556744
    c = [1, 2, 3] 3051365556744
    

    a和c同样指向同一个对象,接下来通过形参a修改列表中的元素。

    def test(a) :
    	a[0] = 6
    	print("a =",a,id(a))
    c = [1,2,3]
    test(c)
    print("c =",c,id(c))
    
    a = [6, 2, 3] 2355399385608
    c = [6, 2, 3] 2355399385608
    

    a和c的id同时发生改变且指向同一对象,原因是修改列表中的元素是对对象进行操作,系统会新建一个对象,然后将新的ID赋给指向原对象的所有变量。所以,对对象进行操作会影响所有指向该对象的变量。可以使用以下两种方法使形参与实参相互独立:

    def test(a) :
    	a[0] = 6
    	print("a =",a,id(a))
    c = [1,2,3]
    #方法一:传副本过去
    test(c.copy())  
    #方法二:
    test(c[:])
    print("c =",c,id(c))
    
    a = [6, 2, 3] 2606175445576
    a = [6, 2, 3] 2606175445576
    c = [1, 2, 3] 2606175445512
    
    展开全文
  • 函数的参数分为形参实参两种。在本小节中,进一步介绍形参实参的特点和两者的关系。形参出现在函数定义中,在整个函数体内都可以使用,离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也...
  • 形参实参影响

    千次阅读 2020-12-25 20:26:44
    形参的改变一般不会影响实参的改变。 传值 void fun1(int a,int b) { int t; t = a; a = b; b = t; } int main() { int a=4,b=3; fun1(a,b); printf("%d %d\n",a,b); return 0; } 输出:4 3 由上面的例子...

    形不改实

    形参的改变一般不会影响实参的改变。

    传值

    void fun1(int a,int b)
    {
    	int t;
    	t = a;
    	a = b;
    	b = t;
    }
    int main()
    {
    	int a=4,b=3;
    	fun1(a,b);
    	printf("%d %d\n",a,b);
    	return 0;
    }
    输出:4 3
    

    由上面的例子可以看出,实参的改变没有影响到实参的改变。
    原因是形参a,b的作用域只在fun1函数里,函数结束形参也就被释放了。而且调用函数fun1时,实参传递给形参时,不是用实参替换形参,而是用实参给形参赋值!
    相当于void fun1(int a=a,int b=b);第一个a或b为形参,第二个a或b为实参,在fun1里,a和b的交换是形参之间的交换,并没有影响实参。

    传址

    void fun2(int *a,int *b)
    {
    	int t;    //注意这里不能定义为int *t;//野指针
    	t = *a;
    	*a = *b;
    	*b = t;
    }
    int main()
    {
    	int a=4,b=3;
    	fun2(&a,&b);
    	printf("%d %d\n",a,b);
    	return 0;
    }
    输出:3 4
    

    原因:将实参的地址赋值给形参,相当于void fun2(int *a=&a,int *b=&b);即形参指针a指向了实参a的地址,形参指针b指向了实参b的地址。*a 和 *b为指向的地址的内容。所以函数调用完会改变实参,将实参的值进行交换。

    是不是传址就会影响到实参呢?
    传址影响到实参的本质是将地址的内容进行改变,若只改变地址也不会影响到形参。

    void fun3(int *a,int *b)
    {
    	int *t;   //这里定义了一个野指针,只要没有对它指向的地址的内容进行操作就不会出错,我们可以改变它的指向。
    	t = a;//将指针t指向了指针a所指向的地址
    	a = b;
    	b = t;
    }
    int main()
    {
    	int a=4,b=3;
    	fun2(&a,&b);
    	printf("%d %d\n",a,b);
    	return 0;
    }
    输出:4 3
    

    原因:这里只是改变了指针的指向,并没有对指针指向的地址内的内容进行操作。fun3函数的作用是指针a指向了实参b的地址,指针b指向了实参a的地址,但指针a,b的生存期只在fun3函数里,函数调用完毕后,指针a,b就不存在了。

    若要改变变量的地址或一级指针,则形参要定义为二级指针。
    二级指针可以理解为地址的地址

    void fun4(int **c,int **d)
    {
    	int *t;
    	t = *c;
    	*c = *d;
    	*d = t;
    }
    int main()
    {
    	int a=4,b=3;
    	int *p=&a,*q=&b,*m=&a,*n=&b;
    	fun4(&p,&q);
    	printf("%d %d %d %d\n",p,q,m,n);
    	return 0;
    }
    输出:6422024 6422028 6422028 6422024
    

    函数有返回值

    int fun4(int m)
    {
    	m=4;
    	return m;
    }
    int main()
    {
    	int a=3;
    	fun4(a);
    	b=fun4(a);
    	printf("a=%d ,b=%d\n",a,b);
    	return 0;
    }
    输出:a=3,b=4
    

    当调用函数时,函数有返回值,但没有将函数赋值给实参,即函数返回值赋值给实参,则实参不会改变。虽然形参的作用域只在函数内,但函数的返回值会暂存在寄存器中,当函数赋值给实参时,会从寄存器中将返回值赋值实参。

    展开全文
  • 本文以实例阐述了C++中形参实参的区别,有助于读者加深对于C++形参实参的认识。 形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也不...
  • 形参影响实参

    千次阅读 2020-08-26 21:16:02
    形参 所谓形参,就是形式参数,在你没有调用它的时候...形参不会影响基本数据类型的实参 public static void changeNumber(int num) { num = 10; System.out.println("执行change方法时" + num); } public stati

    形参

    所谓形参,就是形式参数,在你没有调用它的时候他是没有值的。

    实参

    可以理解为你创建的变量就是实参,有具体的值。就算你不赋值他也会有默认的初始值。

    形参会不会影响实参?

    答案是:会!
    但是并不是全部都会影响
    形参不会影响基本数据类型的实参

    public static void changeNumber(int num) {
            num = 10;
            System.out.println("执行change方法时" + num);
        }
    
    
        public static void main(String[] args) {
            /*基本数据类型*/
            int num = 1;
            System.out.println("执行方法前:" + num);
            changeNumber(num);
            System.out.println("执行方法后:" + num);
        }
    

    输出结果

    执行方法前:1
    执行change方法时10
    执行方法后:1
    

    结果显示基本数据类型时,形参并不会影响实参。
    形参可以影响引用类型的实参

        public static void main(String[] args) {
            /*引用数据类型*/
            StringBuffer stringBuffer = new StringBuffer("abc");
            System.out.println("执行方法前:"+stringBuffer);
            changeString(stringBuffer);
            System.out.println("执行方法后:"+stringBuffer);
        }
    
    
        public static void changeStringBuffer(StringBuffer stringBuffer){
            stringBuffer.append("def");
            System.out.println("执行方法时:"+stringBuffer);
        }
    

    输出结果

    执行方法前:abc
    执行方法时:abcdef
    执行方法后:abcdef
    

    形参影响了引用类型的实参!
    下一个例子!

    public static void main(String[] args) {  
            /*引用数据类型*/
            String string = "abc";
            System.out.println("执行方法前"+string);
            changeString(string);
            System.out.println("执行方法后"+string);
        }
        public static void changeString(String string) {
            string = string.concat("def");
            System.out.println("执行方法时" + string);
    
        }
    

    执行结果:

    执行方法前abc
    执行方法时abcdef
    执行方法后abc
    

    形参没有影响引用类型的实参?
    那么什么情况下才会有 形参影响实参呢?
    这就要考虑到底是怎么改变的。
    首先要知道引用数据类型,变量存储的只是一个地址值!
    形参只有在执行的时候才会创建一个临时的空间存储这个形式参数,方法结束这个形式参数的生命周期就结束了。那么形式参数影响实参的时机就肯定是在这个生命周期内!
    一步一步考虑,调用方法的时候需要将实参传入方法,让形参暂时有一个值,因为是引用数据类型,所以形参此时存储的是和实参一样的地址值。
    此时形式参数进行一系列的操作都是对堆空间中的同一个内容进行操作的,所以如果形式参数对堆空间的值修改了,那么实参再查看堆空间里面的数据的时候就是已经被改变过了的数据。这就是为什么StringBuffer受到了形参的影响的原因。
    那么为什么String就没有受到影响呢?
    changeString()方法种,执行的是String的concat方法。

        public String concat(String str) {
            int otherLen = str.length();
            if (otherLen == 0) {
                return this;
            }
            int len = value.length;
            char buf[] = Arrays.copyOf(value, len + otherLen);
            str.getChars(buf, len);
            return new String(buf, true);
        }
    

    这是String类中的concat方法,怎么处理的不用看明白,直接看他的返回值

    return new String(buf, true);
    

    new是干嘛的?创建了新的对象啊!创建对象就是再堆空间新开辟空间了呀!
    这就意味着此时形参存储的地址值现在已经不再是最开始实参给他的地址值了,不管他在怎么操作都是对一个新的堆空间地址中的数据进行操作,原来的实参的堆空间的数据没有发生过改变,所以方法结束后,实参的内容并没有发生改变。
    总结来说就是形参影响引用数据类型的实参,要看地址值是不是发生了改变,如果形参的地址值发生了改变,那么形参就不会影响实参,如果形参的地址值没有发生改变,那他就会影响实参。

    总结

    形参并不会影响基本数据类型的实参。
    形参只有在存储的地址值不发生变化的时候才会影响实参。

    展开全文
  • 形参实参的区别

    2022-07-12 15:44:49
    需要注意的是,在进行函数调用时,这些实参必须要有明确的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使实参获得确定值。在调用函数过程中发生的实参形参间的数据传递,常称为“虚实结合”。自定义...
  • 本想从语言的角度来分析,无奈功力不够,只能粗浅的尝试一下,于是称之管中窥豹,还望大牛指正
  • Java形参实参

    2022-04-23 16:40:19
    Java语言中一个方法可以是无参的,也可以是有参的,而参数又分为了形参实参形参:用来接收调用方法时传递的参数,只有在被调用时才分配内存,一旦调用结束,就释放内存空间。因此仅在方法内有效。 实参:在...
  • 形参实参

    千次阅读 多人点赞 2021-04-18 17:06:52
    形参变量: 形参变量是功能函数里的变量,只有在被...形参实参的内容拷贝一份,在该函数运行结束的时候释放,实参内容不变。 举例一:(形参不能改变实参) 看看下面这段代码中实参形参的位置, 这个过程中实参
  • 下面小编就为大家带来一篇c++指针使用形参改变实参的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 函数的形参实参

    2022-05-10 08:27:58
    无论实参是何种类型的量,在进行函数调用时,它们必须有确定的值,以便把这些值传送给形参。 形式参数是指函数名后括号中的变量。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。 函数...
  • 10、形参实参

    千次阅读 2021-03-18 15:47:35
    文章目录一、形参实参介绍二、形参实参的具体使用(定义阶段,调用阶段)2.1 位置参数2.2 关键字(实)参数2.3 默认(行)参数2.4 可变长度的参数(\*与\*\*)2.4.1 可变长度的位置参数2.4.2 可变长度的关键字...
  • python 中的形参实参

    千次阅读 2022-03-13 16:51:28
    python 中的形参实参 基本定义 形参:形式参数,在定义函数时,函数名后面括号中的参数; 实参:实际参数,在调用函数时,函数名后面括号内的参数,也就是将函数的调用者提供给函数的参数成为实际参数。 两种...
  • 实参形参是程序设计语言中的通用概念,并不是只有C,C++有而JAVA没有。关于他们两者的区别你知道吗?下面是学习啦小编为大家准备的java中形参实参的区别,希望大家喜欢!java中形参实参的区别篇一形参不能离开...
  • 形参个数 时php会发出警告,因为php的解释机制会认为,有参数被定义了却没有被使用,那很可能会影响函数的功能。所以会发出警告。然而,当 实参个数>形参个数 时,php是不会报错的,它只会取前面的几个参数,多余的则...
  • C#形参实参

    2021-04-12 23:19:56
    C#中的形参实参 形参(形式参数) 在函数定义中出现的参数可以看做是一个占位符,它没有数据,只能等到函数被调用时接收传递进来的数据,所以称为形式参数,简称形参实参(实际参数) 函数被调用时给出的参数...
  • 形参实参的区别:
  • C语言之形参实参详解

    千次阅读 2021-05-21 16:06:52
    就是定义函数的时候,写在函数名小括号后面的参数叫形参实参:实际参数。就是调用函数的时候,调用函数时写在函数名小括号后面的参数就叫实参2).注意项a.实参既可以放常量,也可以放变量,还可以放表达式;形参:它...
  • java中的形参实参

    千次阅读 2021-11-12 21:05:40
    1.形参形参定义在方法(函数)中,只有调用所对应的函数时才会分配给形参内存单元,调用结束后释放所分配的内存单元,因此形参只可以在定义的函数内部使用。 2.实参实参可以是变量,常量,表达式等等。从刚开始...
  • 1.形参就是相当于函数中定义的变量。 2.实参是在运行时的函数调用时传入的参数。 function fn(a, b) { //这里的a,b称为 形参,指定义的参数 console.log(a); //a=1 console.log(b); //b=2 } fn(1, 2) //这里的...
  • 为什么x1x2会改变呢它不是调用的实参不返回吗难道是因为全局变量的问题吗
  • C语言中实参形参之间的数据传递是单向的“值传递”,单向传递,只能由实参传给形参,反之不行 输出格式并没有选择%p而是选择了%d,因为十进制的数看起来更直观 1 值传递 如果只是传递值的话: #include //值...
  • C语言形参实参的区别(非常详细)

    万次阅读 多人点赞 2019-11-03 17:45:23
    如果把函数比喻成一台机器,那么参数就是原材料,返回值就是最终产品;从一定程度上讲,函数的作用...形参(形式参数) 在函数定义中出现的参数可以看做是一个占位符,它没有数据,只能等到函数被调用时接收传递进来...
  • C语言中函数形参实参的区别

    千次阅读 2021-10-02 22:56:10
    众所周知一个函数有两种参数,即形参实参。那么究竟什么是形参什么是实参呢? 形参:在定义函数时指定的参数,在未出现函数调用时,他们并不占用内存中的存储单元。只有在发生函数调用时,函数中的形参才被分配...
  • python的形参实参

    2022-01-05 14:21:00
    一个函数的形参共有四种情况:无参数、普通参数、默认值参数、可变参数 1、无参数: # 定义函数 def test(): print("无参数的情况") # 调用函数 test() 2、普通参数 # 定义函数 def test(name, age): print(...
  • 今天小编就为大家分享一篇Python的形参实参使用方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 如果想要精通学习C语言是比较困难的,除了在平时需要多思考之外,还需要在平时做好日常总结,在学习C语言的时候,有两种不同的参数,一种是形参,一种是实参,二者的作用范围是不同的,形参实参是有很大区别的,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,499
精华内容 66,199
关键字:

形参影响实参

友情链接: linklist.rar