精华内容
下载资源
问答
  • 2021-05-22 06:05:04

    如题,C语言在函数间传递参数时,形参的变化是不会改变实参的值的!!!

    如:

    include

    void main(){

    void swap(int,int);

    int a,b;

    scanf("%d,%d",&a,&b);

    swap(a,b);

    }

    void swap(int a,int b){

    int temp;

    temp = a;

    a = b;

    b = temp;

    }

    因为形参与实参的内存单元不同,所以,只是值传递,并不能直接进行值修改。

    为此,有两种方法可以解决这个问题:

    一个是传递指针,另一个是用return返回值到该变量。

    传递指针:

    void main(){

    void swap(int *,int *);

    int a,b;

    scanf("%d,%d",&a,&b);

    swap(&a,&b);

    }

    void swap(int * a,int * b){

    int temp;

    temp = *a;

    *a = *b;

    *b = temp;

    }

    使用return返回值:

    因为此处定义了两个变量,C语言并不支持多值返回,所以可以返回指针,具体可以是返回结构体,或者是数组。

    返回结构体:

    struct test{

    int a;

    int b;

    };

    void main(){

    struct test aa;

    struct test swap(int,int);

    scanf("%d,%d",&aa.a,&aa.b);

    aa = swap(aa.a,aa.b);

    printf("%d,%d",aa.a,aa.b);

    }

    struct test swap(int a,int b){

    struct test aa;

    aa.a = b;

    aa.b = a;

    return(aa); }

    返回数组指针:

    void main(){

    int a[2];

    int *p;

    int * swap(int,int);

    scanf("%d,%d",&a[0],&a[1]);

    p = swap(a[0],a[1]);

    a[0] = p[0];

    a[1] = p[1];

    printf("%d,%d",a[0],a[1]);

    }

    int * swap(int a,int b){

    int c[2];

    c[0] = b;

    c[1] = a;

    return(c); }

    不过略显麻烦...或许是我想得不够精炼...

    更多相关内容
  • java形参改变会影响实参吗? 昨天做题的时候遇到了这个问题(如图所示),传入的参数是int[]数组,实参跟着形参一起改变了。但是之前传入int型参数时形参改变是不会影响实参的。所以想探究一下这个问题,到底...

    java形参的改变会影响实参吗?

    昨天做题的时候遇到了这个问题(如图所示),传入的参数是int[]数组,实参跟着形参一起改变了。但是之前传入int型参数时形参的改变是不会影响实参的。所以想探究一下这个问题,到底什么情况下形参的改变会影响实参。参数是int[]数组

    1. 形参和实参:首先分清楚形参和实参区别。简要来说形参就是定义方法的时候用到的参数,方法被调用时就是靠它来接收传入的参数。例如上图中的reverse(int[] arr,int k),这里的arr和k就是形参。实参就是调用方法时传进去的参数。例如上图中的reverse(arr,k),这里的arr和k是实参。
    2. 值传递和引用传递: 值传递就是在调用方法时,实参把它的值给到形参,形参把这个值拷贝一份,再拿到方法里用。所以传参之后它俩互不相关了,形参的改变就不会影响到实参。而引用传递,在调用方法时传递的是值的引用,也就是说形参拿到的是实参所对应的内存空间的地址,那么传参之后形参和实参指向的就是同一个内存空间,理所当然实参会跟形参一起改变。

    分清了值传递和引用传递之后再来看文章开头说的int[]和int类型的参数有什么区别。
    当参数为int[]数组:

    // int[]数组作为参数
    public static void main(String[] args){
       	int[] arr = {3,2,1,4}; 
       	reverse(arr,3);
       	System.out.println("翻转后数组为:");
       	for(int i : arr) {
       		System.out.print(i);
       	}
          }
          //翻转数组从0到k-1
          public static void  reverse(int[] arr,int k) {
       	   int i = 0,j=k-1;
       	   int temp=0;
       	   while(i<j) {
       		  temp= arr[i];
       		  arr[i]=arr[j];
       		  arr[j]=temp;
       		  i++;
       		  j--;
       	   }
          }
    

    输出结果:
    在这里插入图片描述
    可见调用方法之后实参跟着形参一起被修改了。

    当参数为int数值:

    // 当参数为int型
     public static void main(String[] args){
    		int a = 0;
    		changeInt(a);
    		System.out.println("主函数中实参a的值为:"+a);
    	   }
    	   //修改数的值
    	   public static void changeInt(int a) {
    		   a=100;
    		   System.out.println("changeInt方法中形参a的值为"+a);
    	   }
    

    输出结果:
    在这里插入图片描述
    可见形参虽然被修改了,但是实参还是原来的值,并没有一起被修改。

    发生这样的情况,原因在于:数组是引用类型,它作为参数时发生的传递是引用传递;而int是基本类型,它作为参数时发生的传递是值传递。

    特别:需要注意的是封装类和String类比较特殊,虽然是引用类型,但是由于其本质是由final修饰的,不能被修改,所以作为传参时实参是不会跟随形参发生改变的。
    例如Integer作为参数:

     public static void main(String[] args){
    		Integer a = 0;
    		changeInt(a);
    		System.out.println("主函数中实参a的值为:"+a);
    	   }
    	   //修改数的值
    	   public static void changeInt(Integer a) {		
    		   a=100;
    		   System.out.println("changeInt方法中形参a的值为"+a);
    	   }
    

    输出结果:
    在这里插入图片描述
    String作为参数:

      public static void main(String[] args){
    		String a = "0";
    		changeString(a);
    		System.out.println("主函数中实参a的值为:"+a);
    	   }
    	   //修改数的值
    	   public static void changeString(String a) {		
    		   a="100";
    		   System.out.println("changeString方法中形参a的值为"+a);
    	   }
    

    输出结果:
    在这里插入图片描述
    总结:例如数组之类的引用类型作为参数时,形参的修改会影响实参;而基本类型和特别的引用类型(封装类、String类)作为参数时,形参的修改不会影响实参。

    关于封装类的地址传递参考链接: Interger是值传递还是地址(引用)传递?

    展开全文
  • 必备知识:c语言中的函数调用和...函数的一个功能就是传递数值进行运算,那么我们如何利用函数和指针变量通过形参变量的值改变实参变量的值呢?首先,让我们先举一个例子。#includeint main(){void func(int a,int ...

    必备知识:c语言中的函数调用和指针变量的相关知识

    众所周知,函数是C语言中一个十分重要的模块,因为函数的存在,使得C语言的可读性、可维护性、可移植性大大提高。因此,想要学好C语言,必须要学好函数。函数的一个功能就是传递数值进行运算,那么我们如何利用函数和指针变量通过形参变量的值改变实参变量的值呢?

    首先,让我们先举一个例子。

    #include

    int main()

    {

    void func(int a,int b);

    int x,y;

    printf("please enter two numbers:\n");

    scanf("%d%d",&x,&y);

    func(x,y);

    printf("%d,%d\n",x,y);

    }

    void func(int a,int b)

    //函数的功能若a>b,则调换a,b的值

    {

    int c;

    if(a>b)

    {

    c=a;

    a=b;

    b=c;

    }

    }

    结果:

    e51c9cd9139d?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

    图片发自简书App

    分析:函数func的功能是若a>b,则调换a,b的值,而我们输入的数为12,6,且12>6,但是值却没有按预期调换,为什么呢?

    这是因为函数调用中,虚实结合传递的是变量的值,且为单向传递,即实际参数向形式参数传递值,但是形式参数却不能向实际参数传递值。因此,在上述的程序中,虽然x的值12传给了a,y的值6传给了b,在被调用的函数func中,a,b的值确实互换了,但是却不能影响实参x,y的值。因此,在调用结束后,x,y的值是不会变化的。

    下面,就开始引入今天的重头戏--指针变量。我们仍然通过一个程序来说明。

    ps:不是我太懒,只是只有通过具体的程序才能更好的理解。

    #include

    int main()

    {

    void func(int *a,int *b);

    int x,y;

    int *x_pointer,*y_pointer;

    printf("please enter two numbers:\n");

    scanf("%d,%d",&x,&y);

    x_pointer=&x;

    y_pointer=&y;

    func(x_pointer,y_pointer);

    printf("The result:\n");

    printf("%d,%d\n",x,y);

    }

    void func(int *a,int *b)

    //函数的功能若a>b,则调换a,b的值

    {

    int c;

    if(*a>*b)

    {

    c=*a;

    *a=*b;

    *b=c;

    }

    }

    结果:

    e51c9cd9139d?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=recommendation

    图片发自简书App

    上面的程序成功地交换了x,y的值,这是为什么呢?

    上述函数调用中,虚实结合传递的仍然是变量的值,且为单向传递,却仍能交换x,y的值,why?

    这就要归功于指针变量了!指针变量即为地址变量,是储存变量在内存中地址的变量。x_pointer=&x,y_pointer=&y即为使x_pointer储存x的地址,y_pointer储存y的地址。

    在函数调用中,传递的是x,y的地址,那么a,b也分别储存x,y的地址,那么*a,*b即为x,y,交换*a,*b的值即为交换x,y的值。所以,通过函数和指针变量即可实现通过形参变量的值改变实参变量的值。

    展开全文
  • 形参会影响实参

    千次阅读 2020-08-26 21:16:02
    就算你不赋值他也会有默认的初始值。 形参会不会影响实参? 答案是:会! 但是并不是全部都会影响 形参不会影响基本数据类型的实参 public static void changeNumber(int num) { num = 10; System.out.println(...

    形参

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

    实参

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

    形参会不会影响实参?

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

    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里面都是值传递,就是形参的值改变是不会改变实参的值的。
  • 本文从“压栈出栈”的角度解释为什么形参变化不会改变实参的值。(注:图中地址是随便写的,旨在示意)
  • 刚学习Java的时候应该都听过Java中没有指针,所以实参传基本数据类型形参改变不会影响实参(基本数据类型存在栈中方法结束后,形参会被弹出栈,实参并没有变化),而实参传入引用数据类型时形参改变会影响实参(引用数据...
  • 当java数组调用一个方法,将数组传进去 public static void main(String[] args) { int arr[] = { 6,1,2,3,4,5 }; sort(arr, arr.length); for (int i = 0;...所以当形参数组的值改变时,实参的值随之改变
  • 浅谈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 的过程中实际是...
  • c语言 形参怎样才使实参的值改变,数组和一般类型数据都分别说一下吧 谢谢答案:6信息版本:手机版解决时间 2019-10-05 16:25已解决2019-10-05 10:41还想问另外个问题main(){ int a=7,b=8,*p,*q,*r;p=&a;q=&...
  • 形参实参的影响

    千次阅读 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 由上面的例子...
  • 对于对象实例,传递的是引用,会改变实参; Note:但实例对象并不是所有情况都改变的,例如自定义一个swap函数交换两个对象,如下: public void swap(A x, A y) { A temp = x; x = y; y = temp; } 这种情况...
  • 形参的值改变不影响实参的值,不是为了说明,形参的值改变,调用函数进行计算出来的值不变,而是为了说明,形参实参同名的情况下,改变形参的值实参的值不变。 34 在C语言中,只有在使用时才占用内存单元的...
  • 五、发生改变的情况 代码:  public static void main(String[] args){  User user=new User("hanmeimei",29);  System.out.println(user);  method1(user);  System.out.println(user);  }  ...
  • 在函数的定义和使用中,存在形参实参这样的概念。假设有如下的函数定义: void func(int a); 此时,定义了一个函数,函数名是func;函数的参数是 int a,那么,这就叫做形参;假设函数有如下的调用: int b = ...
  • #include <stdio.h> void test(int P); int main() { int P = 100;... printf("原来的P是%d\n", P);...函数的形参实参同名时,函数体内改变形参时,函数体外实参不受影响(代码如上图): 输出结果:.
  • c语言说形参不能改变实参的值,为什么这个赋值语句可以0cpystr(q1;printf("cpystr(char *p1,*q2,char *p2){while(*p2++=*p1++);,b),q2);}main(){char *q1=&quot.h>,b[20],q1;q2=b;%s %s"china"stdio#include&...
  • ··如果调用函数传递的参数是可变类型,则在函数内部,使用方法修改了针对参数的内容,同样会改变外部的传递的参数 如: ··+=,在python中,列表使用+=相当于调用列表的extend()方法 如: ...
  • 用指针实现函数形参改变实参 在普通情况下,定义一个带有形参的子函数之后,当调用函数调用该子函数时,实参的值只是复制给形参,再参与子函数里面的数值运算,但原实参的值并不改变, 举个栗子 #include <...
  • swap函数中体现出的c语言函数的值传递机制(形参中int * &是什么意思) 目前初学C语言,对于深层内存机制了解不是十分透彻,只是将自己的理解方式简单记录一下。 我们知道交换两个变量的数值非常简单,只需要一...
  • 形参的数值改变不会改变实参的值

    千次阅读 2013-11-02 13:59:09
    形参值的改变不能使实参的值随之改变,在函数结束时,形参会释放,不可能通过调用函数来改变实参指针变量的值,但是可以改变实参指针变量所指的值(即正确做法)。 (3)void  swap(int *p1,int *p2){ int *...
  • 1.修改值类型,这个实参是完全无法修改的 2.当形参传递的是引用类型时,修改形参的内容,实参...只有传递给形参的是实参的地址的时候,对形参的修改才能改变实参,当形参不指向实参的地址时,修改形参也没用了。 ...
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include #define MAXLINE 1000 /* maximum input line length */int getline(char line[] , int maxline);void copy(char to[] , char from[ ]);/* print the longest ...
  • C#形参实参

    2021-04-12 23:19:56
    函数被调用时给出的参数包含了实实在在的数据,被函数内部的代码使用,所以称为实际参数,简称实参 函数的形参实参区别如下: 形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元...
  • 自定义一个测试函数,通过对比形参实参的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++不同,令我疑惑,遂写此文。 简单实验 我们对常见的数据类型进行实验,检测形参的该表是否...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,860
精华内容 6,744
关键字:

形参的变化也会改变实参

友情链接: ningyiu.zip