精华内容
参与话题
问答
  • C语言中函数参数传递的三种方式

    万次阅读 多人点赞 2017-07-22 21:09:40
    C语言中函数参数传递的三种方式(1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。(2)传址,就是传变量的地址...
    C语言中函数参数传递的三种方式

    (1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。
    (2)传址,就是传变量的地址赋给函数里形式参数的指针,使指针指向真实的变量的地址,因为对指针所指地址的内容的改变能反映到函数外,也就是能改变函数外的变量的值。
    (3)传引用,实际是通过指针来实现的,能达到使用的效果如传址,可是使用方式如传值。
    说几点建议:如果传值的话,会生成新的对象,花费时间和空间,而在退出函数的时候,又会销毁该对象,花费时间和空间。
    因而如果int,char等固有类型,而是你自己定义的类或结构等,都建议传指针或引用,因为他们不会创建新的对象。


    例1:下面这段代码的输出结果为:
    #include<stdio.h>
    void change(int*a, int&b, int c)
    {
          c=*a;
          b=30;
          *a=20;
    }
    int main ( )
    {
          int a=10, b=20, c=30;
          change(&a,b,c);
          printf(“%d,%d,%d,”,a,b,c);
          return 0;
     }
    结果:20  30  30


    解析:
    该题考察函数传参问题。
    1,指针传参 -> 将变量的地址直接传入函数,函数中可以对其值进行修改。
    2,引用传参 -> 将变量的引用传入函数,效果和指针相同,同样函数中可以对其值进行修改。
    3,值传参   -> 在传参过程中,首先将c的值复制给函数c变量,然后在函数中修改的即是函数的c变量,然后函数返回时,系统自动释放变量c。而对main函数的c没有影响。


    例2:
    #include<stdio.h>  
    void myswap(int x, int y)  
    {  
        int t;  
        t=x;  
        x=y;  
        y=t;  
    }  
    int main()  
    {  
        int a, b;  
        printf("请输入待交换的两个整数:");  
        scanf("%d %d", &a, &b);  
        myswap(a,b);  //作为对比,直接交换两个整数,显然不行  
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);  
        return 0;  
    }  
     
     
    #include<stdio.h>  
    void myswap(int *p1, int *p2)  
    {  
        int  t;  
        t=*p1;  
        *p1=*p2;  
        *p2=t;  
    }  
    int main()  
    {  
        int a, b;  
        printf("请输入待交换的两个整数:");  
        scanf("%d %d", &a, &b);  
        myswap(&a,&b);  //交换两个整数的地址  
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);  
        return 0;  
    }  
     
    #include<stdio.h>  
    void myswap(int &x, int &y)  
    {  
        int t;  
        t=x;  
        x=y;  
        y=t;  
    }  
      
    int main()  
    {  
        int a, b;  
        printf("请输入待交换的两个整数:");  
        scanf("%d %d", &a, &b);  
        myswap(a,b);  //直接以变量a和b作为实参交换  
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);  
        return 0;  
    }  
    第一个的运行结果:输入2 3,输出2 3 
    第二个的运行结果:输入2 3,输出3 2
    第三个的运行结果:输入2 3,输出3 2

    解析:
    在第一个程序中,传值不成功的原因是指在形参上改变了数值,没有在实参上改变数值。
    在第二个程序中,传地址成功的原因利用指针改变了原来的地址,所以实参就交换了。

    在第三个程序中,引用是直接改变两个实参变量a,b的值,所以就交换了。

    下文会通过例子详细说明关于值传递,指针传递,引用传递 

      1)值传递:

        形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,

    不能传出。当函数内部需要修改参数,并且不希望这个改变影响调用者时,采用值传递。

      2)指针传递:

        形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作

      3)引用传递:

        形参相当于是实参的“别名”,对形参的操作其实就是对实参的操作,在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

        下面的代码对此作出了细致解释(从实参,形参在内存中存放地址的角度 说明了问题的本质,容易理解  )

     1 #include<iostream>
     2 using namespace std;
     3 //值传递
     4  void change1(int n){
     5     cout<<"值传递--函数操作地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址 
     6     n++;
     7 }
     8 
     9 //引用传递
    10 void change2(int & n){
    11     cout<<"引用传递--函数操作地址"<<&n<<endl; 
    12     n++;
    13 }
    14  //指针传递
    15 void change3(int *n){
    16      cout<<"指针传递--函数操作地址 "<<n<<endl; 
    17     *n=*n+1;
    18  } 
    19 int     main(){
    20     int n=10;
    21     cout<<"实参的地址"<<&n<<endl;
    22     change1(n);
    23     cout<<"after change1() n="<<n<<endl;
    24     change2(n);
    25     cout<<"after change2() n="<<n<<endl;
    26     change3(&n);
    27     cout<<"after change3() n="<<n<<endl;
    28     return true;
    29 }

    运行结果如下,(不同的机器可能会有所差别)

    可以看出,实参的地址为0x22ff44

        采用值传递的时候,函数操作的地址是0x22ff20并不是实参本身,所以对它进行操作并不能改变实参的值

    • 再看引用传递,操作地址就是实参地址 ,只是相当于实参的一个别名,对它的操作就是对实参的操作
    • 接下来是指针传递,也可发现操作地址是实参地址

        那么,引用传递和指针传递有什么区别吗?

      引用的规则: 
    引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。 

    • 不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)。 
    • 一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。 

      指针传递的实质:

        指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的

        任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)如果理解不了大可跳过这段

      指针传递和引用传递一般适用于:

        函数内部修改参数并且希望改动影响调用者。对比指针/引用传递可以将改变由形参“传给”实参(实际上就是直接在实参的内存上修改,不像值传递将实参的值拷贝到另外的内存地址中才修改)。

        另外一种用法是:当一个函数实际需要返回多个值,而只能显式返回一个值时,可以将另外需要返回的变量以指针/引用传递给函数,这样在函数内部修改并且返回后,调用者可以拿到被修改过后的变量,也相当于一个隐式的返回值传递吧。

        以下是我觉得关于指针和引用写得很不错的文章,大家可参照看一下,原文出处地址:http://xinklabi.iteye.com/blog/653643 

        从概念上讲。指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

        而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。

        在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的:

        指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)

    而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

        引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。

    为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别:

    程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。

    最后,总结一下指针和引用的相同点和不同点:

      1)相同点:

    • 都是地址的概念;

    指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名。

      2)不同点:

    • 指针是一个实体,而引用仅是个别名;
    • 引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终”,指针可以“见异思迁”;
    • 引用没有const,指针有const,const的指针不可变;(具体指没有int& const a这种形式,而const int& a是有     的,  前者指引用本身即别名不可以改变,这是当然的,所以不需要这种形式,后者指引用所指的值不可以改变)
    • 引用不能为空,指针可以为空;
    • “sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身的大小;
    • 指针和引用的自增(++)运算意义不一样;
    • 引用是类型安全的,而指针不是 (引用比指针多了类型检查)
    复制代码
    一、引用的概念
    
    引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似,只是用&代替了*。
    例如: Point pt1(10,10);
    Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义,pt1和pt2表示同一对象。
    需要特别强调的是引用并不产生对象的副本,仅仅是对象的同义词。因此,当下面的语句执行后:
    pt1.offset(22);
    pt1和pt2都具有(1212)的值。
    引用必须在定义时马上被初始化,因为它必须是某个东西的同义词。你不能先定义一个引用后才
    初始化它。例如下面语句是非法的:
    Point &pt3;
    pt3=pt1;
    那么既然引用只是某个东西的同义词,它有什么用途呢?
    下面讨论引用的两个主要用途:作为函数参数以及从函数中返回左值。 
    
    二、引用参数
    
    1、传递可变参数
    传统的c中,函数在调用时参数是通过值来传递的,这就是说函数的参数不具备返回值的能力。
    所以在传统的c中,如果需要函数的参数具有返回值的能力,往往是通过指针来实现的。比如,实现
    两整数变量值交换的c程序如下:
    一、引用的概念
    
    引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似,只是用&代替了*。
    例如: Point pt1(10,10);
    Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义,pt1和pt2表示同一对象。
    需要特别强调的是引用并不产生对象的副本,仅仅是对象的同义词。因此,当下面的语句执行后:
    pt1.offset(2,2);
    pt1和pt2都具有(12,12)的值。
    引用必须在定义时马上被初始化,因为它必须是某个东西的同义词。你不能先定义一个引用后才
    初始化它。例如下面语句是非法的:
    Point &pt3;
    pt3=pt1;
    那么既然引用只是某个东西的同义词,它有什么用途呢?
    下面讨论引用的两个主要用途:作为函数参数以及从函数中返回左值。 
    
    二、引用参数
    
    1、传递可变参数
    传统的c中,函数在调用时参数是通过值来传递的,这就是说函数的参数不具备返回值的能力。
    所以在传统的c中,如果需要函数的参数具有返回值的能力,往往是通过指针来实现的。比如,实现
    两整数变量值交换的c程序如下:
    void swapint(int *a,int *b)
    {
    int temp;
    temp=*a;
    a=*b;
    *b=temp;
    }
    
    使用引用机制后,以上程序的c++版本为:
    void swapint(int &a,int &b)
    {
    int temp;
    temp=a;
    a=b;
    b=temp;
    }
    调用该函数的c++方法为:swapint(x,y); c++自动把x,y的地址作为参数传递给swapint函数。
    
    2、给函数传递大型对象
    当大型对象被传递给函数时,使用引用参数可使参数传递效率得到提高,因为引用并不产生对象的
    副本,也就是参数传递时,对象无须复制。下面的例子定义了一个有限整数集合的类: 
    const maxCard=100; 
    Class Set 
    {
    int elems[maxCard]; // 集和中的元素,maxCard 表示集合中元素个数的最大值。 
    int card; // 集合中元素的个数。 
    public:
    Set () {card=0;} //构造函数
    friend Set operator * (Set ,Set ) ; //重载运算符号*,用于计算集合的交集 用对象作为传值参数
    // friend Set operator * (Set & ,Set & ) 重载运算符号*,用于计算集合的交集 用对象的引用作为传值参数 
    ...
    }
    先考虑集合交集的实现
    Set operator *( Set Set1,Set Set2)
    {
    Set res;
    for(int i=0;i<Set1.card;++i)
    for(int j=0;j>Set2.card;++j)
    if(Set1.elems[i]==Set2.elems[j])
    {
    res.elems[res.card++]=Set1.elems[i];
    break;
    }
    return res;
    }
    由于重载运算符不能对指针单独操作,我们必须把运算数声明为 Set 类型而不是 Set * 。
    每次使用*做交集运算时,整个集合都被复制,这样效率很低。我们可以用引用来避免这种情况。
    Set operator *( Set &Set1,Set &Set2)
    { Set res;
    for(int i=0;i<Set1.card;++i)
    for(int j=0;j>Set2.card;++j)
    if(Set1.elems[i]==Set2.elems[j])
    {
    res.elems[res.card++]=Set1.elems[i];
    break;
    }
    return res;
    }
    
    三、引用返回值
    
    如果一个函数返回了引用,那么该函数的调用也可以被赋值。这里有一函数,它拥有两个引用参数并返回一个双精度数的引用:
    double &max(double &d1,double &d2)
    {
    return d1>d2?d1:d2;
    }
    由于max()函数返回一个对双精度数的引用,那么我们就可以用max() 来对其中较大的双精度数加1:
    max(x,y)+=1.0;

    展开全文
  • Java中的参数传递

    万次阅读 多人点赞 2018-01-19 13:52:15
    Java中没有真正的引用传递 只有值传递! 传引用参数指的还是原来的那个引用,但是Java...指的是在方法调用时,传递参数是按值的拷贝传递。示例如下: public class TempTest { private void test1(int a){ //

    Java中没有真正的引用传递 只有值传递!

    传引用参数指的还是原来的那个引用,但是Java里面参数类型是对象时是复制了原来的引用到一块新的内存,两者之间没有关系

    1:按值传递是什么

    指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:

        public class TempTest {
            private void test1(int a){
            //做点事情
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                int a = 3;
                t.test1(a);//这里传递的参数a就是按值传递
            }
        }

    按值传递重要特点:传递的是值的拷贝,也就是说传递后就互不相关了。

    示例如下:

        public class TempTest {
            private void test1(int a){
                a = 5;
                System.out.println("test1方法中的a="+a);
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                int a = 3;
                t.test1(a);//传递后,test1方法对变量值的改变不影响这里的a
                System.out.println(”main方法中的a=”+a);
            }
        }

    运行结果是:
    test1方法中的a=5
    main方法中的a=3

    2:按引用传递是什么

    指的是在方法调用时,传递的参数是按引用进行传递,其实传递的引用的地址,也就是变量所对应的内存空间的地址。

    示例如下:

        public class TempTest {
            private void test1(A a){
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                A a = new A();
                t.test1(a); //这里传递的参数a就是按引用传递
            }
        }
        class A{
            public int age = 0;
        }

    3:按引用传递的重要特点

    传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

    示例如下:

        public class TempTest {
            private void test1(A a){
                a.age = 20;
                System.out.println("test1方法中的age="+a.age);
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                A a = new A();
                a.age = 10;
                t.test1(a);
                System.out.println(”main方法中的age=”+a.age);
            }
        }
        class A{
            public int age = 0;
        }

    运行结果如下:
    test1方法中的age=20
    main方法中的age=20

    4:理解按引用传递的过程——内存分配示意图

    要想正确理解按引用传递的过程,就必须学会理解内存分配的过程,内存分配示意图可以辅助我们去理解这个过程。

    用上面的例子来进行分析:

    (1):运行开始,运行第8行,创建了一个A的实例,内存分配示意如下:
    这里写图片描述
    (2):运行第9行,是修改A实例里面的age的值,运行后内存分配示意如下:
    这里写图片描述

    (3):运行第10行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:
    这里写图片描述
    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:
    这里写图片描述
    也就是说:是两个变量都指向同一个空间。

    (4):运行第3行,为test1方法中的变量a指向的A实例的age进行赋值,完成后形成的新的内存示意图如下:
    这里写图片描述
    此时A实例的age值的变化是由test1方法引起的

    (5):运行第4行,根据此时的内存示意图,输出test1方法中的age=20

    (6):运行第11行,根据此时的内存示意图,输出main方法中的age=20
    5:对上述例子的改变

    理解了上面的例子,可能有人会问,那么能不能让按照引用传递的值,相互不影响呢?就是test1方法里面的修改不影响到main方法里面呢?

    方法是在test1方法里面新new一个实例就可以了。改变成下面的例子,其中第3行为新加的:

        public class TempTest {
            private void test1(A a){
                a = new A();//新加的一行
                a.age = 20;
                System.out.println("test1方法中的age="+a.age);
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                A a = new A();
                a.age = 10;
                t.test1(a);
                System.out.println(”main方法中的age=”+a.age);
            }
        }
        class A{
            public int age = 0;
        }

    运行结果为:
    test1方法中的age=20
    main方法中的age=10
    为什么这次的运行结果和前面的例子不一样呢,还是使用内存示意图来理解一下

    6:再次理解按引用传递

    (1):运行开始,运行第9行,创建了一个A的实例,内存分配示意如下:
    这里写图片描述
    (2):运行第10行,是修改A实例里面的age的值,运行后内存分配示意如下:
    这里写图片描述
    (3):运行第11行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:
    ![这里写图片描述]
    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

    这里写图片描述
    也就是说:是两个变量都指向同一个空间。

    (4):运行第3行,为test1方法中的变量a重新生成了新的A实例的,完成后形成的新的内存示意图如下:
    这里写图片描述
    (5):运行第4行,为test1方法中的变量a指向的新的A实例的age进行赋值,完成后形成的新的内存示意图如下:
    这里写图片描述
    注意:这个时候test1方法中的变量a的age被改变,而main方法中的是没有改变的。

    (6):运行第5行,根据此时的内存示意图,输出test1方法中的age=20

    (7):运行第12行,根据此时的内存示意图,输出main方法中的age=10

    7:说明

    (1):“在Java里面参数传递都是按值传递”这句话的意思是:按值传递是传递的值的拷贝,按引用传递其实传递的是引用的地址值,所以统称按值传递。

    (2):在Java里面只有基本类型和按照下面这种定义方式的String是按值传递,其它的都是按引用传递。就是直接使用双引号定义字符串方式:String str = “Java私塾”;

    展开全文
  • 参数传递的方式

    2007-01-31 19:22:43
    总的来说,计算机语言给子程序传递参数的方法有两种。第一种方法是按值传递(call-by-value )。这种方法将一个参数值(value )复制成为子程序的正式参数。这样,对子程序的参数的改变不影响调用它的参数。第二种...

    总的来说,计算机语言给子程序传递参数的方法有两种。第一种方法是按值传递(call-by-value )。这种方法将一个参数值(value )复制成为子程序的正式参数。这样,对子程序的参数的改变不影响调用它的参数。第二种传递参数的方法是引用调用(call-by-reference )。在这种方法中,参数的引用(而不是参数值)被传递给子程序参数。在子程序中,该引用用来访问调用中指定的实际参数。这样,对子程序参数的改变将会影响调用子程序的参数。根据传递的对象不同,Java 将使用这两种不同的方法。

    对于原始数据类型,也就是int longchar之类的类型,是传值的,如果在方法中修改了值,方法调用结束后,那个变量的值没有改变。

    对于对象类型,也就是Object的子类,如果你在方法中修改了它的成员的值,那个修改是生效的,方法调用结束后,它的成员是新的值,但是如果你把它指向一个其它的对象,方法调用结束后,原来对它的引用并没有指向新的对象。 

     

     

    展开全文
  • 实现参数传递的几种方式

    千次阅读 2017-08-03 10:55:26
    由于web系统采用http协议在浏览器和... 表单传递参数是一种最简单,也是最基本的参数传递方式。注意:表单元素隐藏按钮的使用  方式二:带参数的url方式传递  带参数的url写法: url?参数名1=值1&参数名2=值2。
     由于web系统采用http协议在浏览器和服务器之间传输数据,而http协议是一种无状态的协议,如何在不同页面之间、或页面向后端传递数据,可以有一下几种方式
       方式一:表单方式传递
       表单传递参数是一种最简单,也是最基本的参数传递方式。注意:表单元素隐藏按钮的使用
       方式二:带参数的url方式传递
       带参数的url写法: url?参数名1=值1&参数名2=值2。
       方式三:请求request对象
       可以将数据绑定到request对象上,通过request对象getAttribute和setAttribute方法读写
       方式四:用户会话session对象
       可以将数据绑定到session对象上,通过session对象getAttribute和setAttribute方法读写
       方式五:application对象
       可以将数据绑定到application对象上,通过application对象getAttibute方法和setAttribute方法读写
       方式六:cookie对象
       可以将数据写到到客户端浏览器cookie文件中。

       其中方式一,方式二只能实现字符串参数的传递,方式三,四,五,六可以实现对象的传递(方式六需要对象序列化后进行存储)
       方式一,方式二,方式三数据传递只能请求页面获取数据,而方式四,五,六可以在多个不同页面获取数据对象
       方式四和六保存的数据对象都是和某个用户相关的信息,不同的是方式四将数据保存到服务器内存中,方式六将数据保存到客户端内存中。
       方式五保存的数据对象都是和所有用户相关的信息,数据也是保存到服务器内存中
    展开全文
  • 参数传递

    2020-11-16 16:28:28
    基本类型数据作为参数传递给方法,方法内部改变了参数,不会影响外部 //2.引用类型数据作为参数传递给方法,方法内部改变了参数,会影响外部 //3.引用类型数据作为参数传递给方法,方法内部改变了参数的指向,不会影响外部...
  • 方法及方法参数传递

    2019-04-20 18:16:38
    方法及方法参数传递 1.方法 1) 在Java中把能够独立实现某一具体功能的代码称为方法, 该代码能重复使用 2) 方法的声明: 修饰符 返回值类型 方法名(形式参数){功能代码语句} 其中: 返回值类型 方法名(){} 这两个是...
  • 参数是如何传递的?

    2019-01-25 19:24:33
    参数是通过赋值传递的 形参和实参的区别和关系:  定义函数时:  int add(int a,int b) a,b就是形参  调用时:  add(1,2) ...
  • 传递包括实实在在的值传递以及指针传递(指针传递参数本质上是值传递的方式,它所传递的是一个地址值),传递的都是实参的一个拷贝。 1、实实在在的“值”传递 #include &lt;iostream&gt; #include &...
  • 参数的两种传递方式详解

    千次阅读 2011-11-12 11:21:37
    值传递是将要传递的值作为一个副本进行传递;而引用传递则是传递引用对象的内存地址。 下面则是对这两个的详解 ...值传递是参数在调用函数前后不发生...PHP中除了对象类型外,其他类型的参数传递都是值传递。 2:
  • JS参数传递(值传递和引用传递)

    万次阅读 多人点赞 2018-06-07 15:11:01
    书P66 一个加粗框中写到:ECMAScript中所有参数传递都是值,不可能通过引用传递参数当时看过没有怎么仔细想过,一知半解吧,今天理解的更加深一些。当然也是昨天做了个题目就因为这个掉坑里一时没爬出来!访问变量有...
  • C语言中函数参数传递的三种方式 (1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。 (2)传址,就是传变量的...
  • java中的参数传递(只有值传递没有引用传递)

    万次阅读 多人点赞 2019-07-31 19:25:14
    Java中只有传值调用(值传递),没有传址调用(址传递或者引用传递)。所以在java方法中改变参数的值是不会改变原变量的值的,但为什么改变引用变量的属性值却可以呢?请看下面的解答。 java中的数据类型 Java中...
  • java 参数传递实例

    2018-11-01 14:26:23
    java到底是值传递还是地址传递,网上说什么都有,面试的时候我也说不清,我让面试官举例子,我直接说结果,面试官说算了! 好了,回到正题,具体似乎什么传递我也说不清,举几个例子说明一下。 1.基本类型,包装...
  • java 传递参数的两种方式

    万次阅读 多人点赞 2015-10-19 15:39:28
    Java中没有指针,所以也没有引用传递了,仅仅有值传递不过可以通过对象的方式来实现引用传递 类似java没有多继承 但可以用多次implements 接口实现多继承的功能  值传递:方法调用时,实际参数把它的值传递给对应...
  • C++参数传递java参数传递对比
  • java利用方法参数传递这个问题困扰了我一天,关于java传参有三种传递方式,《java核心技术卷I》里也提到了。 1.一个方法不能修改一个基本数据类型的参数 ( 即数值型或布尔型 ),String类型也不行 。 2.一个方法...
  • Java 5 中提供了变长参数,允许在调用方法时传入不定长度的参数。变长参数Java 的一个语法糖,本质上还是基于数组的实现: void Example(String...str) {} void Example(String[] str) {} // 相当于一个...
  • 闲言少叙,下面我们就通过内存模型的方式来讨论一下Java中的参数传递。 这里的内存模型涉及到两种类型的内存:栈内存(stack)和堆内存(heap)。基本类型作为参数传递时,传递的是这个值的拷贝。无论你怎么改变这个...
  • java传参

    2019-09-13 00:50:01
    不造轮子,原文地址:... 之前用的c/c++比较多,在c/c++中对于传参类型,无外乎就是传值、传引用、传指针这几种。但在java中,由于没有指针类型,其传参的方式也发生了相应的变化。根...
  • Java对象,对象引用,参数传递

    千次阅读 2018-07-01 19:45:46
    Java中,万物皆对象! 比如定义一个学生类 public class Student { private int id; private String name; private int age; public Student() { // TODO Auto-generated constructor stub su...
  • JAVA中数组作为函数参数传递

    万次阅读 2019-06-01 16:00:18
    package test03; public class test { public static void array(int [] arrayA){ arrayA[0]=0; } public static void main(String[] args) { int [] arrayA = new int []{1,2,3,4}; ...
  • class squ{ public static int square(int x,int y){ int V; V=x*x+y*y; return V; } } public class KY4_2 { public static void main(String[] args) { int a=5; int b=3;... S...
  • Java 泛型的类型与参数传递

    千次阅读 2016-10-19 15:18:29
    泛型的类型 泛型的参数传递过程
  • java传参方式

    千次阅读 2017-09-01 17:02:58
    java传参分两种类型,java都是值传递 1.基本类型使用值传递,形参是对实参的一个拷贝,在方法里对形参修改不影响实参的值 2.引用类型是引用值传递,对于类的实例它传递的是类的引用,形参是对实参的引用值得...
  • 这两者都算是java基础中的基础,平常写代码可能并没有过多的去深究它,但这样容易引发一些不可预知的BUG。 这里有一个简单的类,文章中会提到多次。 一个学生类,它有两个属性,String类型的name与Integer类型的...
  • ![图片说明]...图里面那个参数tclass在jsp里面还是正确的,我加过out.print测试过。在CardApplet中取这个参数用的是tclass = getParameter("tclass");结果发现是null。这是什么问题?求大神。
  • Java接口作为参数传递

    千次阅读 2019-04-08 11:36:07
    记录两种方式,原文链接:Java接口作为参数传递【用处很多】http://www.jufanshare.com/content/70.html 原文中解释比较详细,此处只有实现代码 方式一: package com.jufanshare; /** * @功能: * @开发者:...
  • JAVA参数传递方式 (按值传递与引用传递区别)

    千次阅读 热门讨论 2018-09-30 22:58:30
    首先要明确的是JAVA中没有引用传递, 全部是按值调用 令大家所费解的 当对象引用作为参数时 函数为什么能修改真实的对象呢?这不是引用传递的特征吗? 尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为, 用...
  • null作为参数传递的时候,就不是引用传参Java参数引用传递之例外:null 众所周知的是,java中除基本类型外,参数都是引用传递。 但是,有一个例外,就是当实参为null时,其实,它依然是一个值传递。 也就是...
  • public void test() { int a = 1; String tobePass = "before"; stu(a); Log.v(TAG, "after stu, a is: " + a); stu2(tobePass);... Log.v(TAG, "after stu, tobePass is: " + tobePass);... ...

空空如也

1 2 3 4 5 ... 20
收藏数 1,775,607
精华内容 710,242
关键字:

参数传递