参数传递解析（转贴）

最新推荐文章于 2022-07-13 18:09:10 发布
最新推荐文章于 2022-07-13 18:09:10 发布
阅读量228 收藏
点赞数
分类专栏： Java基础 文章标签： C C++ C# J#
 
Java和C++中的参数传递
  
1概念定义
 
1.1按值传递：
将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。
 
1.2按引用传递：
 
将一个参数传递给一个函数时，函数接收的是原始值的内存地址，不是值的副本。因此，如果函数修改了该参数指向的内容，调用代码中的原始值也随之改变。
 
2 C++和Java应用程序中的参数传递
    C++和Java中，当参数不是引用时，传递的都是该值的一个副本（按值传递）。
区别在于引用：
在C++中参数是引用时，您传递的就是这个引用，或者内存地址（按引用传递）。
在Java中参数是对象引用时，您传递的是该引用的一个副本（按值传递），而不是引用本身，但是调用方法的对象引用和副本都指向同一个对象。
总之，Java应用程序在传递不同类型的参数时，其作法与C++并无不同。Java应用程序按值传递所有参数，这样就制作所有参数的副本，而不管它们的类型。
 
3 实例解析
 
3.1代码一（C++版本）
 
#include<iostream></iostream> 
using namespace std;
 
void modify(int a, int *p, int &r)
{
    printf("in modify...\n");
    a = 0;
    *p = 7;
    p = 0;
    r = 0;
    printf("a is %d\n", a);
    printf("p is %d\n", p);
    printf("r is %d\n", r);
}
 
int main ()
{
 int val, ref;
 int *pint;
 
 val = 10;
 ref = 50;
 pint = (int*)malloc(sizeof(int));
 *pint = 15;
 
 printf("val is %d\n", val);
 printf("pint is %d\n", pint);
 printf("*pint is %d\n", *pint);
 printf("ref is %d\n\n", ref);
 
 printf("calling modify\n");
  
 modify(val, pint, ref);
 printf("returned from modify\n\n");
 
 printf("val is %d\n", val);
 printf("pint is %d\n", pint);
 printf("*pint is %d\n", *pint);
 printf("ref is %d\n", ref);
 
 return 0;
}
程序运行结果：
val is 10
pint is 4262128
*pint is 15
ref is 50
 
calling modify
in modify...
a is 0
p is 0
r is 0
returned from modify
 
val is 10
pint is 4262128
*pint is 7
ref is 0
 
这段代码声明了三个变量：两个整型变量和一个指针变量。将所有三个变量作为参数传递给modify()。前两个参数是按值传递的，最后一个参数是按引用传递的。
Modify()的函数原型表明最后一个参数要作为引用传递。C++按值传递所有参数，引用除外；
Modify()更改了所有三个参数的值：
将第一个参数设置为0。
将第二个参数所指向的值设置为7，然后将第二个参数设置为0。
将第三个参数设置为0。
将新值打印出来，然后函数返回。
当执行返回到main时，再次打印出这三个参数的值以及指针所指向的值。
第一个和第二个参数由于按值传递，所以实参不受modify函数的影响。但指针所指向的值改变了。最后一个参数由于按引用传递，所以实参被modify函数改变了。
 
 
3.2代码二（Java版本）
 
class Test
{
    public static void modify( int a, StringBuffer r1, StringBuffer r2)
    {
        System. out .println( "in modify..." );
        a = 0;
        r1 = null ; //1
        r2.append( " taste good" );
        System. out .println( "a is " + a);
        System. out .println( "r1 is " + r1);
        System. out .println( "r2 is " + r2);
    }
 
    public static void main(String args[])
    {
        int val;
        StringBuffer sb1, sb2;
 
        val = 10;
        sb1 = new StringBuffer( "apples" );
        sb2 = new StringBuffer( "pears" );
        System. out .println( "val is " + val);
        System. out .println( "sb1 is " + sb1);
        System. out .println( "sb2 is " + sb2);
        System. out .println();
 
        System. out .println( "calling modify" );
        // 按值传递所有参数
        modify(val, sb1, sb2);
        System. out .println( "returned from modify" );
        System. out .println( "" );
 
        System. out .println( "val is " + val);
        System. out .println( "sb1 is " + sb1);
        System. out .println( "sb2 is " + sb2);
    }
}
 
运行结果：
val is 10
sb1 is apples
sb2 is pears
 
calling modify
in modify...
a is 0
r1 is null
r2 is pears taste good
returned from modify
 
val is 10
sb1 is apples
sb2 is pears taste good
代码声明了三个变量：一个整型变量和两个对象引用。将所有三个变量作为参数传递给modify()。
Modify()更改了所有三个参数的值：
将第一个参数（整数）设置为0。
将第一个对象引用r1设置为null。
保留第二个引用r2的值，但调用append()更改它所引用的对象
返回到main()时，整型的val没有改变。对象引用sb1也没有改变。
如果sb1是按引用传递的，正如许多人声称的那样，它将为null。但是，因为Java中按值传递所有参数，所以是将sb1的引用的一个副本传递给了modify()方法。
当modify()中将r1设置为null时，它只是对sb1的引用的一个副本进行了该操作，而不是像C++中那样对原始值进行操作。
第二个对象引用sb2打印出的是在modify()中设置的新字符串。是因为modify()中的引用副本和sb2指向同一个对象，所以对复制的引用所调用的方法更改的是同一个对象。
 
 
3.3经典的交换函数
 
3.3.1利用指针来实现
 
 void swap(int *a, int *b)
{
 int temp = *b;
 *b = *a;
 *a = temp;
}
 
int main (int argc, char** argv)
{
 int val1, val2;
 val1 = 10;
 val2 = 50;
 swap(&val1, &val2);
 return 0;
}
 
3.3.2利用引用来实现
 
 void swap(int &a, int &b)
{
 int temp = b;
 b = a;
 a = temp;
}
 
int main (int argc, char** argv)
{
 int val1, val2;
 val1 = 10;
 val2 = 50;
 swap(val1, val2);
 return 0;
}
 
 
3.3.3 Java利用引用来实现
 
  class Swap
{
    public static void swap(Integer a, Integer b)
    {
        Integer temp = a;
        a = b;
        b = temp;
    }
   
    public static void main(String args[])
    {
        Integer a, b;
 
        a = new Integer(10);
        b = new Integer(50);
 
        System. out .println( "before swap..." );
        System. out .println( "a is " + a);
        System. out .println( "b is " + b);
        swap(a, b);
        System. out .println( "after swap..." );
        System. out .println( "a is " + a);
        System. out .println( "b is " + b);
    }
}
 
运行结果：
before swap...
a is 10
b is 50
after swap...
a is 10
b is 50
Java中的函数参数传值是按值传值！
 
 
3.4 Java版本的综合实例
 
  class MyInteger
{
    private int     inner ;
   
    public MyInteger( int inner)
    {
        this . inner = inner;
    }
   
    public void setInt( int i)
        {
            inner = i;
        }
 
        public int getInt()
        {
            return inner ;
        }
 
        public String toString()
        {
            return "" + inner ;
        }
    }
 
class Swap
{
    public static void swap(MyInteger a, MyInteger b)
    {
        pl( "swap" );
        MyInteger temp = a;
        a = b;
        b = temp;
    }
 
    public static void swapI(MyInteger a, MyInteger b)
    {
        pl( "swapI" );
        MyInteger temp = a;
        a = new MyInteger(b.getInt());
        b = new MyInteger(temp.getInt());
    }
 
    public static void swapII(MyInteger a, MyInteger b)
    {
        pl( "swapII" );
        int temp = a.getInt();
        a.setInt(b.getInt());
        b.setInt(temp);
    }
   
    public static void main(String[] args)
    {
        MyInteger a = new MyInteger(1);
        MyInteger b = new MyInteger(2);
        pl(a);
        pl(b);
        swap(a, b);
        pl(a);
        pl(b);
        swapI(a, b);
        pl(a);
        pl(b);
        swapII(a, b);
        pl(a);
        pl(b);
    }
 
    private static void pl(Object a)
    {
        System. out .println(a);
    }
}
 
运行结果：
1
2
Swap //交换的是实参的引用副本，所以对原来的调用函数没什么影响
1
2
swapI //操作的是实参的引用副本
1
2
swapII //操作的是引用副本所指向的内容，所以对调用函数会发生变化
2
1
 
总之，在函数参数传递的过程当中Java自动调用Object::clone()，想要进行深拷贝的调用，自己要显示的指明！
public static void swap(MyInteger i, MyInteger j)
{
    i.setValue(40);
    j.setValue(50);
}
swap ((MyInteger)a.clone(),(MyInteger)b.clone());
 
 
3.5 思考下面的例子
 
 package hziee; 
 
public class StringTest
{
    static void func(String s)
    {
        s += "tail" ;
    }
 
    static void test()
    {
        String a = "abc" ;
        func(a);
        System. out .println(a);
    }
 
    public static void main(String[] args)
    {
        test();
    }
}
 
看了上面的介绍内容应该明白是什么原因了吧？
iteye_19433
关注
专栏目录
Java与C++ 传递参数包括数据，字符串，基本数据类型
搭建单机版Flink环境实现数据从Kafka流入ES
07-06 508
项目背景:某项目中需要Java调用底层C++写的算法，底层算法用的是opencv，算法那边提供的接口是传递一个opencv封装的Mat对象，返回的也是处理后的Mat对象，还有一些基本的配置参数,准备直接传图片路径,C++去读取图片转化为Mat，但是考虑到读取IO效率问题，最后决定Java传字节数组,C++接口做预处理转化为Mat对象，解析算法得到处理后的Mat对象，最后转化为base64返回给java后台，最后通过websocket把处理后的图片实时显示到前端页面 java调用C++实例程序可以参考我上一篇
C++与java中的参数传递
重剑无锋
08-18 1326
  Java传值与传引用。对基本数据类型传递值，对象则传引用。传递对象时，若在被调函数体内改变了对象的值，那么在调用函数内对象的值也会改变。试试下面一段代码。void testValue(int i)    ...{        i=100;    }    void testInteger(Integer i)    ...{        i=new Integer(200);   
JAVA 和C++ 参数传递
fzjjj123的博客
05-04 398
C++#include &lt;iostream&gt;using namespace std;class Box{   public:      int x;   };/****值传递   在函数栈中复制了一份外部变量的值。与java对象是引用类型，函数栈中只保留对象地址不同，在C++中，复制整个对象的内容到函数栈中。****/void Fun1(Box b)  {  Box b1; b1....
浅谈JAVA和C++两者的参数传递
sniperDing的博客
09-22 946
浅谈JAVA和C++两者的参数传递
Java与C++参数传递方式对比
bsbhenry的专栏
12-06 410
1 Java Java中方法（函数）的参数传递只有按值调用一种方式。只是在方法内部产生了一个参数的拷贝。 方法参数分为两种： 1.基本数据类型。方法无法修改参数的值。 2.对象引用。假设一个类Employee有一个raiseSalary的方法，在tripleSalary函数中调用该方法。 public static void tripleSalary(Employee x){ ...
C语言难点解析：变量作用域、函数与递归
理解函数的调用、参数传递（实参与形参）和返回值是关键。 - 递归函数：函数在其定义中调用自身。理解和绘制递归调用树是理解和解决问题的关键。递归需要特别注意防止无限循环和栈溢出。 3. 数组：一组相同类型的...
linux内核关机函数,Linux 关机命令分析[转贴]
weixin_42484898的博客
05-09 851
Linux 关机命令分析任桥伟MSN：ilttv@hotmail.comEmail：ilttv@163.comlinux下有关关机重启的命令主要有：shutdown、reboot、halt、poweroff、telinit、init。它们都可以达到关机或重启的目的，但是每个命令的工作流程并不一样。它们都由软件包sysvinit产生，你可以从网上下载它的源码来分析各个命令的流程，同时，sysvini...
Delphi RTTI 解析
流年~~
10-20 4797
Delphi 的RTTI机制浅探 目 录 =============================================================================== ⊙ DFM 文件与持续机制(persistent) ⊙ ReadComponentResFile / WriteComponentResFile 函数 ⊙ Delphi 持续机制框架
寒霜系列引擎技术解析
mmqqyyqqyyq的博客
11-03 4848
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; http://hi.b
ASP.net难点解析
热门推荐
NDK2010_的专栏
12-02 1万+
认识Asp.net 中相对路径与绝对路径 分类： 技术文档2010-01-1217:051490人阅读评论(1)收藏举报 好多人对相对路径与绝对路径老是混淆记不清楚，我从整理了一下，希望对大家的认识有帮助。 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1.Request.Applicat
【Java】关于Java中参数传递方式与C++的比较
Jin_Kwok的博客
05-09 3643
【写作原由】     今天刚刚刷了一道二叉树路径搜索的题（LeetCode 113 Path Sum II），在采用熟悉的C++解答之后，用Java语言再次撸了一遍，发现一些问题，特别是参数传递的问题：  【C++】      在C/C++中，参数传递分为两种：值传递和地址传递，其中：      1.值传递：实际参数将值传递给形式参数，对形式参数进行操作不影响实际参数，如： int
C/C++ 和Java 相互传递参数通信
hj_key的博客
05-13 1313
一、C 中 调用JAVA（Activity ）中方法，传递 数据 大体分两种： 1、先在activity 中调用JNI 方法，然后通过C 中反射，找到activity的类以及方法，进行调用。该方法有个弊端，只能在当前线程中使用，项目中用处实用性太小。 2、本文主推方法： 在activity 中先启动一个JNI 调用，讲activity 当前类 保存到C中存为全局变量，然后在需要使用的C 文件中，使用这个全局变量找到activity的类，和方法，然后进行调用。话不多说，上干货！ 在JNI加载完后..
参数传递的解释
teddylu的专栏
09-23 1521
第一，JAVA 里的参数传递只有值传递，没有所谓的引用传递。（说白了，是因为大家的说法 不统一） 第二，引用一个强人的观点 jamesfancy()边城狂人(James Fancy) ： “1. 首先明白参数的传递实质是压栈和出栈的过程。即在调用一个方法(或说子程序)之前，先将需要传入的参数压栈，然后执行代码的指针跳转到方法的起始位置，进行出栈操作，原来压入栈
Java与C++参数传递机制的区别
houjingchuan的博客
07-13 562
首先，我们要知道在调用方法时，传入的实参不会直接在方法内使用，而是重新在栈中申请一个副本(形参)来使用。这种传递方法称作值传递。如果参数是基本数据类型，此时实参给形参的是实参真实存储的数据值。 内存结构解析 : 在调用 swap 方法时，方法的形参会新生成两个 int 类型变量 m 、n。在方法内，形参的 m 、n 得到交换，与main方法中的 m 、n 无关，只是将其值传给了形参而已。如果仍然想要使用方法来交换main方法中 m 、n的值，那么就将其封装在类中，通过对象 . 属性来交换两个变量的值 ...
参数传递
dyckkkk的博客
09-23 429
python参数传递 1什么是参数传递 参数传递，是在程序运行过程中，实际参数就会将参数值传递给相应的形式参数，然后在函数中实现对数据处理和返回的过程，方法有按值传递参数，按地址传递参数和按数组传递参数。 2位置传递和名称传递 有两个形参a和b，反馈结果为a*b的值，令ab等于1.2，输出结果为2 def add(a,b): return a*b result=add(1,2) print(result) 结果输出 3可变参数的传递 用元组类型为案例 def add(a,*b): s=0
参数传递是什么？参数传递的是什么？
一起加油吧~
05-14 3663
目录 过程是什么？ 什么是参数的传递？ 如果传递参数数据类型不匹配会怎么样？ 参数传递传的是什么？ 传值（ByVal） 传地址（ByRef，默认） 过程是什么？ 执行一段相同的程序代码 有哪些过程？ Sub Function 子程序 函数 Call语句调用 Call语句调用 没有返回值 有返回值 为什么要使用过.
C++、Java的函数传参分析
HarryWg的博客
04-14 128
对于基本类型，C++与Java均为传值调用，那么对于对象传参，二者是否有不同的机制呢。 C++函数传参分析 #include<iostream> class Dog { private: int id; //狗狗id public: Dog(int id_) //有参构造函数 { std::cout << "Constructing Dog" << std::endl; this->id = id_;
php空值的3种表示方法,is_null(),empty(),isset()三个函数的功能，参数，返回值+手抄作业...
weixin_34434843的博客
03-10 1626
特别提示:这三个函数仅适用于变量判断,不要直接到用字面量上面。一、is_null()函数的功能，参数，返回值1.功能:is_null()—检测变量是否为NULL;2.语法:bool is_null ( mixed $var )如果 $var 是 null 则返回 TRUE，否则返回 FALSE。查看 NULL 类型获知变量什么时候被认为是 NULL，而什么时候不是。参数描述: mixed...
linux 输入三个参数 输出运运结果,【shell】shell基础
weixin_36485139的博客
05-13 1314
一、数据类型1.shell变量运行shell时，会同时存在三种变量：1) 局部变量局部变量在脚本或命令中定义，仅在当前shell实例中有效，其他shell启动的程序不能访问局部变量。2) 环境变量所有的程序，包括shell启动的程序，都能访问环境变量，有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。3) shell变量shell变量是由shell程序设置的特...
FPC吸附胶纸转贴组件技术解析
资源摘要信息:"在现代电子制造业中，FPC（Flexible Printed Circuit，柔性印刷电路板）的吸附胶纸转贴组件是一种重要的设备装置。FPC是电子设备内部连接电子元件的一种线路板，其特点是可弯曲、可折叠、重量轻、厚度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值