精华内容
下载资源
问答
  • c语言我们都知道形参不能改变实参,实参能改变形参,我们能保证自己很熟悉这个概念吗,能不能保证自己每次都不犯错,掉坑里。 #include <iostream.h> #include <string.h> void fun( char *s) { char a...

    c语言我们都知道形参不能改变实参,实参能改变形参,我们能保证自己很熟悉这个概念吗,能不能保证自己每次都不犯错,掉坑里。
    #include <iostream.h>
    #include <string.h>
    void fun( char *s)
    {
    char a[10];
    strcpy ( a, “AAAAAA” );
    cout<<“形参未改变,实参传递给实参的值:”<<s<<endl;
    s=a;
    cout<<"形参改变后字符串后的值: "<<s<<endl;
    }
    main( )
    {
    char *p= “BBBBBB” ;
    fun( p );
    cout<<"实参在形参被改变后的值: "<<p<<endl;
    }
    这是我自己写的实参改变形参的一段代码,末尾我会附上运行截图
    在谈论这个问题前先明确几个概念

    形参是什么?
    形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。

    实参是什么?
    实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使实参获得确定值。

    要实现调用函数,形参传递到实参要注意的事项有哪些?

    实参的类型,数量定义的顺序都是不能改变的,这样才能调用,不然会出现不匹配错误,比如定义一个函数
    void ss(int a,char c) //a和c就是形参
    我们在调用的时候就要提前定义实参,严格按照 整形,字符型的顺序才能调用
    int f;
    char v;
    ss(f,v);//f和v就是实参
    参数的传递方向是单向的,只能从实参传到形参(不要妄想形参反客为主改变实参,那是不可能的,之后用代码进一步证明)

    附上我写的字符串复制的例子,感兴趣的话可以自己实践一下,也可以复制我的操作一下

    简单解释一下我的这个指针指向的例子
    实参p是字符型指针,赋给初始值为BBBBBB,然后利用函数,形参为字符型指针s,形参改变实参的证明就是我们没给s赋初值但是初始值为实参的值,这里输出BBBBBB,所以实参改变了形参;

    s初始值和实参一样为BBBBBB,我们这里继续改变形参的值,改为AAAAAA,输出,发现形参s改变成AAAAAA;

    我们都知道C语言是从上到下按顺序执行的,我们在main函数调用函数后来看一下有没有通过改变形参的值改变了实参,输出实参p,实际上没有改变,实参p的值依然是BBBBBB,所以实参并没有受到改变;

    本人很菜,有什么不完全或者有误的地方请指出,有问题请留言或者私聊我,写作不易,有帮助的话请留下一个赞,谢谢。
    附上我的运行截图帮助理解:

    在这里插入图片描述

    展开全文
  • class Student{ int a = 1; @Override public String toString() { return "Student [a=" + a + "]";...是因为赋的那个值超范围是方法区中的...当然不是,是因为所有的包装类都是final修饰的,都是可变类。

    class Student{

    int a = 1;

    @Override
    public String toString() {
    return "Student [a=" + a + "]";
    }

    public Student(int a) {
    this.a = a;
    }

    }

    public class Java_Test {
    private int a = 1;
    private Integer b = 200;
    private Double d = 20.2;
    private Boolean bool = true;
    private Student s = new Student(1);
    //传入的是:基本类型
    public void show(int n ) {
    System.out.println("基本类型修改前:"+n);
    n = 3;
    System.out.println("基本类型修改后:"+n);
    }

    //传入的是:包装类Integer
    public void show(Integer n ) {
    System.out.println("包装类修改前:"+n);
    n = 300;
    System.out.println("包装类修改后:"+n);
    }
    //传入的是:包装类Double
    public void show(Double n ) {
    System.out.println("包装类修改前:"+n);
    n = 30.3;
    System.out.println("包装类修改后:"+n);
    }
    //传入的是:包装类Boolean
    public void show(Boolean n ) {
    System.out.println("包装类修改前:"+n);
    n = false;
    System.out.println("包装类修改后:"+n);
    }

    //传入的是:对象
    public void show(Student s ) {
    System.out.println("对象修改前:"+s.a);
    s.a = 3;
    System.out.println("对象修改后:"+s.a);
    }


    public void test() {
    //基本类型int
    System.out.println("传入一个基本类型数字:"+a);
    show(a);
    System.out.println("基本类型最终值:"+a);
    System.out.println("------------------");

    //包装类Integer
    System.out.println("传入一个包装类数字:"+b);
    show(b);
    System.out.println("包装类最终值:"+b);
    System.out.println("------------------");

    //包装类Double
    System.out.println("传入一个包装类数字:"+d);
    show(d);
    System.out.println("包装类最终值:"+d);
    System.out.println("------------------");

    //包装类Boolean
    System.out.println("传入一个包装类数字:"+bool);
    show(bool);
    System.out.println("包装类最终值:"+bool);
    System.out.println("------------------");

    //对象Student
    System.out.println("传入一个对象数字:"+s);
    show(s);
    System.out.println("包装类最终值:"+s);

    }


    public static void main(String[] args) {
    new Java_Test().test();
    }

    }

    是因为赋的那个值不超范围是方法区中的缓冲的值?

    当然不是,是因为所有的包装类都是final修饰的,都是不可变类。


    展开全文
  • 当函数需要用形参改变实参时,简单的传值不能解觉问题。这时就需要使用指针解决问题。 例:int a=10;b=20;要求写一个函数将a,b的值互换。 错误代码: 1. //交换失败,原因a,b仅仅只是赋值,main中的a和Swap中的a不是...

    当函数需要用形参改变实参时,简单的传值不能解觉问题。这时就需要使用指针解决问题。

    例:int a=10;b=20;要求写一个函数将a,b的值互换。
    错误代码:
    1.

    //交换失败,原因a,b仅仅只是赋值,main中的a和Swap中的a不是同一个变量
    void Swap_err(int a,int b)
    {
     int tmp = a;
     a = b;
     b = tmp;
    }
    //交换失败,只是交换形参的指向(交换钥匙),没有解引用
    void Swap_err2(int *p1,int *p2)
    {
     int *tmp = p1;
     p1 = p2;
     p2 = tmp;
    }
    void Swap_err3(int *p1,int *p2)
    {
     int *tmp;//野指针,悬挂指针,tmp是个局部变量,默认值为随机值
     *tmp = *p1;//*tmp崩溃,野指针不能访问
     *p1 = *p2;
     *p2 = *tmp;
    }

    正确代码:

    void Swap(int *p1, int *p2)
    {
     int tmp = *p1;
     *p1 = *p2;
     *p2 = tmp;
    }
    int main()
    {
     int a = 10;
     int b = 20;
     printf("%d,%d\n", a, b);
     Swap(&a, &b);
     printf("%d,%d\n", a, b);
     return 0;
    }

    运行结果:
    在这里插入图片描述

    展开全文
  • 基础缺失2、形参实参

    2020-06-09 14:54:09
    形参在函数定义中,函数体内使用,调用结束即刻释放; 函数体外不能使用。 实参在主调函数中,被调函数中不能使用。 一般调用时,只能实参传给形参,不能形参传...若函数参数不是指针时,调用函数不能改变实参的值 ...

    版权声明!原创!转载请附上原文出处链接!

    先上百度知道里一位大佬的简洁明了的回答!!!!
    在这里插入图片描述

    1、形参在函数定义中,函数体内使用,调用结束即刻释放; 函数体外不能使用。

    2、实参在主调函数中,被调函数中不能使用。

    3、一般调用时,只能实参传给形参,不能形参传给实参。

    4、实参形参在数量上,类型上,顺序上应严格一致, 否则会发生“类型不匹配”的错误。

    5、若函数参数是指针时,函数体内可改变实参的值

    :传给函数的是实参的地址,在函数体内使用的也是实参的地址,即实参本身。

    6、若函数参数不是指针时,调用函数不能改变实参的值

    展开全文
  • 形参实参

    2021-04-18 17:06:52
    形参变量: 形参变量是功能函数里的变量,只有在被调用的时候才分配内存单元,调用结束后立即释放。所以形参只在函数内部...举例一:(形参不能改变实参) 看看下面这段代码中实参和形参的位置, 这个过程中实参并
  • 形参实参

    2019-09-28 17:25:22
    2.当传值调用时,改变的是形参的值,并没有改变实参的值,实参的值可以传递给形参,但是,这个传递是单向的,形参不能传递回实参。 3.当引用调用时,如果参数是对象,无论对对象做了何种操作,都不会改变实参对象的...
  • python 中,数据类型分为 可变(mutable) 和 不可变(unmutable)。...(对比, 在c或者c++ 中,函数调用 发生的数据传递时单向的, 即, 只能把实参的值 传递给形参, 而不能形参的值传给实参。在函数调
  • 但是由于Java的JVM的机制,我们并不能够获得真正的存储地址,是JVM根据不同的平台自动分配,这也就导致了我们不能手动传递地址,JAVA将自动为引用传递传递一个地址。 一、两种类型:基本类型 和 引用类型 基本类型...
  • (c++)当数组做函数参数若形参改变有方法使实参不改变
  • 对于指针,同样不能企图通过改变指针形参的值而使指针实参的值改变。因为他们采用的都是单向的“值传递”方式,实参可以把数据传给形参形参却不可以把数据传回给实参。 #include using namespace std; int main...
  • 然后我就理解了,如果说是形参在函数调用完毕就释放而且没有return语句的话,主函数的值应当发生改变。这样的话,代码1的主函数的实参数值交换没法解释。当然代码2和3按照这个逻辑是可以解释的。还有代码1的swap...
  • 2,单向传递,形参中的指针子函数改变地址后不能传给主调函数,变量同样指向了我们希望处理的数据,然后对形参的指针变量指向的数据进行各种希望的处理,在调用函数运行完成后,各个形参指针变量进行了释放。...
  • 形参实参区别

    2020-06-23 20:24:19
    这里写自定义目录标题形参实参区别欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成...形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。 实参出现在主调函数中
  • 2、不能通过改变形参指针的值(形参所指向的地址)来改变实参指针的地址,实现改变实参指针所指向地址变量的值。 #include "stdio.h"   swap(int *p1,int *p2) {int *temp; temp=p1; p1=p2; ...
  • 形参实参的比较

    千次阅读 2018-08-25 13:41:26
    1、形参出现在函数定义中,在整个函数体内部都可以使用,离开该函数则不能使用。实参出现在主调函数中,主调函数中调用一个函数时,函数名后面括号中的参数称为实参。 2、函数调用中发生的数据传送是单向的,只能把...
  • 形参实参的区别

    2020-12-20 14:00:03
    2)在方法调用的时候,只能把实参的值传送给形参不能形参的值反向的传递给实参,因此,在方法调用过程中,对形参值的改变不会影响实参的值 如下例所示: public class Test { public static void f(int n) { n++; ...
  • 值传递方式: ...在函数中可以修改形参的值,但不能改变其对应的实参的值(形参的值变化无法传送到实参) 原因:在函数调用时将建立一个新的对象,是实参对象的拷贝,实参形参分别占有不同的存储...
  • 形参改变如何影响实参

    千次阅读 2016-08-10 21:24:04
    在编程中,形参改变是无法影响实参的,那么有什么办法将数据返还给调用自己的上层函数呢? 通过return,全局变量,指针,引用即可。 return的缺点是每次只能返回一个参数;如果想返回多个,可能需要将数据存入...
  • 函数形参实参注意事项: 1.未进行函数调用时,形参并不占内存存储单元。只有调用函数,形参才被分配内存,调用结束形参内存单元被释放。...5.值传递:只能实参传给形参不能形参传给实参,用指针可以改变值。 ...
  • 指针变量作函数参数,调用结束后,不能改变实参指针变量的值但可以改变实参指针变量所指向变量的值。 /* 2013年11月7日 */ /*一般变量作函数参数*/ #include"iostream" using namespace std; void swap(int x, int ...
  • 实参形参 C++

    2012-09-21 22:50:00
    值传递方式: 1、普通调用,形参与...在函数中可以修改形参的值,但不能改变其对应的实参的值(形参的值变化无法传送到实参) 原因:在函数调用时将建立一个新的对象,是实参对象的拷贝,实参形参分别占有不同...
  • 如题,这是因为 :1,按值传递,在调用函数的时候,将指向数据的指针实参传递到调用函数的形参中去2,单向传递,形参中的指针子函数改变地址后不能传给主调函数,变量同样指向了我们希望处理的数据,然后对形参的...
  • [code="java"]void swap(int *p1, int *p2) { int *p; p= p1; p1= p2; p2 = p; } void main() { int x=10,y=100; int *px=x,*py=y; printf("%d,%d",*px,*py); ...[/code]
  • 然后我就理解了,如果说是形参在函数调用完毕就释放而且没有return语句的话,主函数的值应当发生改变。这样的话,代码1的主函数的实参数值交换没法解释。当然代码2和3按照这个逻辑是可以解释的。还有代码1的swap...
  • 形参实参的引用

    2017-10-31 13:04:09
    虚函数重写,返回值的类型不能改变虚函数重写,返回值的类型不能改变虚函数重写, 返回值的类型不能改变刚学C++遇到的问题: 重载运算符 输入流>>时, 函数定义的形参必须是实参的引用(别名) 虚函数重写,返回值...
  • 1.方法的形参中,java的基本数据类型是传值调用,对象引用...2.当传值调用时,改变的是形参的值,并没有改变实参的值,实参的值可以传递给形参,但是,这个传递是单向的,形参不能传递回实参。 3.当...
  • 对于函数形参实参,我其实也不能说太明白,这里只是我作为一个初学者的一些自我理解,如果有错误,希望大家指出。 在这里我就不去细说形参实参的概念了,这里的a,b就是实参,而x,y就是形参。 在用整形,浮点型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 483
精华内容 193
关键字:

形参能不能改变实参