精华内容
下载资源
问答
  • 形参实参影响
    千次阅读
    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
    

    由上面的例子可以看出,实参的改变没有影响到实参的改变。
    原因是形参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
    

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

    更多相关内容
  • 形参影响实参

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

    总结

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

    展开全文
  • Java中将实参传给方法之后,值发生改变是在方法里面,没有影响实参。 栈内存的特点是先进后出,如同装东西一样,最先装进去的东西往往是最后出来的 附上测试代码: public class Test { public static ...

    Java中将实参传给方法之后,值发生改变是在方法里面,没有影响到实参。

    栈内存的特点是先进后出,如同装东西一样,最先装进去的东西往往是最后出来的

    附上测试代码:

    public class Test {
    
    public static void main(String[] args) {
    
    int one=1;
    
    int two=2;
    
    System.out.println("one的值"+one+"two的值"+two);
    
    three(one,two);
    
    System.out.println("one的值"+one+"two的值"+two);
    
    }
    
    public static void three(int num1,int num2){
    
    int test;
    
    test=num1;
    
    num2=test;
    
    num1=num2;
    
    }
    
    }

    展开全文
  • 自定义一个测试函数,通过对比形参实参的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
    
    展开全文
  • §对于绝大多数情况下,在函数内部直接修改形参的值不会影响实参。例如:>>> def addOne(a):print(a)a += 1print(a)>>> a = 3>>> addOne(a)34>>> a3§在有些情况下,可以通过...
  • JAVA:形参改变对实参影响

    千次阅读 2020-12-22 14:08:40
    JAVA:形参改变对实参影响 熟悉C/C++的同学都知道,如果想在传入形参的函数中,实现形参改变,实参也跟着改变的话,我们需要手动将实参的地址或引用传入给形参,这样形参生成的拷贝副本,就是实参指向存储单元的...
  • 浅谈c++中形参不能改变实参

    千次阅读 2020-04-03 18:48:52
    c语言我们都知道形参不能改变实参实参能改变形参,我们能保证自己很熟悉这个概念吗,能能保证自己每次都犯错,掉坑里。 #include <iostream.h> #include <string.h> void fun( char *s) { char a...
  • 形参不能传任何东西给实参实参传过去的东西都是一个副本!!! 下面以一个交换数据的被调函数片段为例 在指针变量由实参传递给形参时传过去的实际是指针变量的值,即一个地址,在 t=*p1 *p1=*p2 *p2=t 的过程中实际是...
  • 形参如何改变实参

    2021-12-17 21:34:45
    形参实参
  • 形参影响实参

    千次阅读 2018-04-24 22:53:00
    b当参数类型是引用数据类型时,若修改形参指向的内容会影响实参,因为形参实参指向的是同一块区域c当参数类型时引用数据类型时,若先修改形参的指向后再修改形参指向的内容则不会影响实参的数值,因为此时二者指向...
  • java形参的改变会影响实参吗? 昨天做题的时候遇到了这个问题(如图所示),传入的参数是int[]数组,实参跟着形参一起改变了。但是之前传入int型参数时形参的改变是不会影响实参的。所以想探究一下这个问题,到底...
  • 例如:fun(x=0,y=1),fun(x,y=1),但可以是fun(x=1,y) 形参设置可以为数字字符串变量、元组和字典等任意类型数据,元组形参是在变量名前加*,字典形参是在变量名前加** 例如:fun(var),fun(*tuple),fun(*list),fun...
  • 1.修改值类型,这个实参是完全无法修改的 2.当形参传递的是引用类型时,修改形参的内容,实参...只有传递给形参的是实参的地址的时候,对形参的修改才能改变实参,当形参不指向实参的地址时,修改形参也没用了。 ...
  • 1.当使用基本数据类型作为参数传递时,形参变量的改变不会影响实参的数值; 即如果形参是基本类型或者String,则实参不会变(传的是值) public class Test { public static void main(String[] args) { ...
  • 函数的参数分为形参实参两种。在本小节中,进一步介绍形参实参的特点和两者的关系。形参出现在函数定义中,在整个函数体内都可以使用,离开该函数则能使用。实参出现在主调函数中,进入被调函数后,实参变量也...
  • 形参实参

    千次阅读 2021-04-18 17:06:52
    形参变量: 形参变量是功能函数里的变量,只有在被调用的时候才分配内存单元,调用结束后立即释放。所以形参只在函数内部...举例一:(形参不能改变实参) 看看下面这段代码中实参形参的位置, 这个过程中实参
  •  但要注意的是:当方法中将形参重新指向新对象时,对实参地址的指向就被中断而无法继续对实参进行操作。还有当形参为String类型时,一旦对其做出修改就会指向新的对象而中断对实参的指向。         转载...
  • 方法用父类对象作形参 调用时用子类对象作实参, 则在该方法内使用的是 父类对象的方法。打个断点但运行以下 看看执行步骤你就明白了~using System;using System.Collections.Generic;using System.Linq;using ...
  • 首先Java里面都是值传递,也就是形参的值改变是不会改变实参的值的。
  • 四、传递对象发生修改情况 代码: public class UserTest {  public static void main(String[] args){  User user=new User("hanmeimei",29);  System.out.println(user);  method(user);  ...
  • 实参:可以是常量、变量、表达式、函数等, 无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的.../*** 注意:* 传递参数:形参(方法中)的改变有没有影响实参(main函数中)* 1.基本数据类型 没有影响* ...
  • 父类有了带参数的构造函数,子类的构造函数可以和父类的构造函数一样,但是,如果你的父类定义了带参数的构造函数同时没有无参重载的情况下,那么在子类中,你必须对父类的带参数的构造进行赋值,也就是实参!...
  • C语言形参实参的区别(非常详细)

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

    千次阅读 2020-09-07 12:13:16
    此时,我们把调用func函数时,传递给形参变量的数据称为:实参,如果传递给形参变量的数据是一个变量,我们称该变量为:实参变量。例如: intb = 8; func(b); 此时,定义了变量b,给变量b赋值8数值;然后,...
  • 形参的改变如何影响实参

    千次阅读 多人点赞 2016-08-10 21:24:04
    在编程中,形参的改变是无法影响实参的,那么有什么办法能将数据返还给调用自己的上层函数呢? 通过return,全局变量,指针,引用即可。 return的缺点是每次只能返回一个参数;如果想返回多个,可能需要将数据存入...
  • 在js函数中,形参的作用是用来接收实参传来的数据,(形参可以接收任何数据类型的数据,数组,字符串…函数等等) 举例: function sum(num1, num2) { let a = num1 + num2; return a; } console.log(sum(1, 2)); 其中...
  • 无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。 形式参数(形参): 形式参数是指函数名后括号中的变量,因为形式参数只有在函数被调用的过程中才实例化(分配内存单元...
  • Java——形参实参的区别

    千次阅读 2021-02-12 10:03:14
    形参出现在函数定义中,在整个函数体内都可以使用,离开该函数则能使用。实参出现在主调函数中,进入被调函数后,实参变量也能使用。形参实参的功能是作数据传送。发生函数调用时,主调函数把实参的值传送给被...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,523
精华内容 63,809
关键字:

形参不影响实参