Java VS C++ 传值与函数参数传值

最新推荐文章于 2023-07-05 14:11:21 发布
最新推荐文章于 2023-07-05 14:11:21 发布
阅读量308 收藏
点赞数
分类专栏： 基本概念 文章标签： java C++ 传值 函数参数传值 引用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22341213/article/details/52198338
版权

一、变量传值

Java

  1. 类对象 // 传引用  
  2. 原始数据类型 // 传值
  3. String自身不带修改函数，每次操作都生成一个String对象。可以认为是传值。

 

C++

  1. 基本数据类型变量传值  //传值
  2. 一般指针传值  // 与int型相似，传值
  3. 类对象变量传值 // 相当于用某个对象来初使化新建对象
  4. 类指针对象变量传值  // 与int 类型相似，传值

二、函数传值

Java

拷贝复制传值

基本数据类型：拷贝复制变量的值，不能改变外部的地址和值。

类对象：拷贝复制传递对象的引用，不会改外部的地址，但能能过这个引用，改蛮对象的数据值。

C++

拷贝复制传值

基本数据类型：拷贝复制变量的值，不能改变外部的地址和值。

类对象：拷贝复制传值，在函数内部不能修改传入数据对象的数据。

指针或引用：能在函数内部修改传入对象或变量的数据。不能修改外部的地址，除非在函数内部有新建指针变量并将其返回给输入指针。如：int *set(int *p){return new int(10);}   int a = 11;int *pa = &a; pa = set(pa);。这一点JAVA中的引用也是如此。

Java 与 C++ 函数参数传值方式均为拷贝复制传值。两者区别只在于传入的东西的“表像”的不一样。


三、JAVA中的引用与C++的区别

JAVA中的引用，对类对象有此说法，对基础类型变量无此说法。

对类对象的引用，例如：设有类Test，则

Test t1 = new Test();

Test t2 = t1;

// t2为t1的一个引用（t1,t2具有相同的地址）

变量t1,t2相当于C/C++中的指针，它们指向同一个内存（具有相同的地址）

C++中，引用与指针是不同的概念。对对象及基础数据类型都有定义，设有类Test，如

Int a = 10;

Int &b = a;//创建a的一个引用。

Test ta = Test();

Test tb = ta;

Test &tc = ta;

// b 为a的一个引用，两者的地址相同。无论引用对象是类对象、数据类型对象还是指针。

 

 

顺便说一下

int a = 0;

int b = a;//先创建int型变量b中，在将a的值赋给b。

 

Test ta = Test();//创建Test 类对象ta

Test tb = ta;// 创建Test类对象，再用ta来初使化tb。故ta与tb的地址不同，数据相同

  // 此句与Testtb;tb = ta;等效

Test &tc = tb;// 创建类Test 对象tb的引用 tc。tc 与tb有相同的地址。指向同一片内存空间

 

Test *pa = new Test();// 创建类指针对象 pa，并默认初使化

Test *pb =pa; // 创建Test类指针对象并将 地址pa赋给pb。

Test *&pc = pa; // 创建 pa的一个引用pc ,从而pc与pa具有相同地址

// 故，pa，pb，pc指向同一内存空间

四、测试代码及运行结果

Java引用，函数传值代码

publicclass JavaCodeTest

{

public JavaCodeTest()

{

// TODO自动生成的构造函数存根

}

 

public static void main(String[] args)

{

// TODO自动生成的方法存根

Test a = new Test(001, "name001");

Test b = new Test(002, "name002");

print("a: " + a + " ");

a.print();

 

print("b: " + b + " ");

b.print();

print("Swapping......\n");

swap(a, b);

 

print("a: " + a + " ");

a.print();

 

print("b: " + b + " ");

b.print();

 

print("\n");

}

 

public static void swap(Test a, Test b)

{

Test tem = new Test();

tem.copy(a);

a.copy(b);

b.copy(tem);

 

}

 

public static void print(String str)

{

System.out.print(str);

}

}

 

classTest extends Object

{

int           id;

String        name;

 

Test()

{

}

 

Test(int id)

{

this.id = id;

}

 

Test(String name)

{

this.name = name;

}

 

Test(int id, String name)

{

this.id = id;

this.name = name;

}

 

Test(String name, int id)

{

this.id = id;

this.name = name;

}

 

public int getId()

{

return id;

}

 

public String getName()

{

return name;

}

 

public void print()

{

System.out.println("id = " + id + ",name = " +name);

}

 

public void copy(Test obj)

{

this.id = obj.id;

this.name = obj.name;

}

@Override

public Test clone()

{

return (new Test(this.id, this.name));

 

}

}

//输出结果

a:test.TestJava.Test@2a139a55 id = 1,name = name001

b:test.TestJava.Test@15db9742 id = 2,name = name002

Swapping......

a:test.TestJava.Test@2a139a55 id = 2,name = name002

b:test.TestJava.Test@15db9742 id = 1,name = name001


//引用测试

/*

 * C++/C引用测试

 */

#include<iostream>

usingnamespace std;

classTest

{

    public:

int val;

Test();

Test(int val);

~Test();

 

int getVal();

void setVal(int val);

};

Test::Test(){this->val= 0;};

Test::Test(intval){this->val = val;};

Test::~Test(){};

 

intTest::getVal(){return this->val;}

voidTest::setVal(int val){this->val = val;}

intmain()

{

    int a = 11;

    int b = a;

    int &c = a;

    cout << "Value:";

    cout << "a = "<< a<<"    b = "<< b<<"    c = "<< c<<endl;

    cout << "address:" <<"&a:" << &a <<"    &b" << &b<<"    &c" <<&c << endl;

 

    Test ta = Test(12);

    Test tb = ta;

    Test &tc = ta;

    Test td = Test();

    cout << endl <<"ObjectTest:" << endl;

    cout <<"Value:";

    cout << "ta.val = "<< ta.val << "    tb.val= "

    << tb.val <<"    tc.val = " << tc.val<< endl;

    cout << "Address:" <<&ta << "    "<< &tb << "   " << &tc << endl;

 

    cout << "Amendta"<<endl;

    ta.setVal(13);

    cout << "ta.val = "<< ta.val << "    tb.val= "

    << tb.val <<"    tc.val = " << tc.val<< endl;

    cout << "Address:" <<&ta << "    "<< &tb << "   " << &tc << endl;

    cout << "Amendtb"<<endl;

    tb.setVal(15);

    cout << "ta.val = "<< ta.val << "    tb.val= "

    << tb.val <<"    tc.val = " << tc.val<< endl;

    cout << "Address:" <<&ta << "    "<< &tb << "   " << &tc << endl;

    cout << "Amendtc"<<endl;

    tc.setVal(21);

    cout << "ta.val = "<< ta.val << "    tb.val= "

    << tb.val <<"    tc.val = " << tc.val<< endl;

    cout << "Address:" <<&ta << "    "<< &tb << "   " << &tc << endl;

 

    cout << "Init td with Address:" << &td << endl;

    td = ta;

    cout << "After td = ta ......tdget Address :  " << &td<< endl;

    cout << "The val in td :"<< td.val << endl;

 

    cout << endl <<"ObjectPointer Test:" << endl;

    Test *pa = new Test(11);

    Test *pb = pa;

    Test *&pc = pa;

    Test *pd = new Test();

    cout << "Value: " <<endl;

    cout << "pa : " <<pa->val << "\tpb : " << pb->val << "\tpc: " << pc->val << endl;

   cout << "Address : "<<endl << pa << "   " << pb << "   " << pc << "   " << endl;

    cout << "Amend pa :"<< endl;

    pa->setVal(14);

    cout << "pa : " <<pa->val << "\tpb : " << pb->val << "\tpc: " << pc->val << endl;

    cout << "Amend pb : "<< endl;

    pb->setVal(17);

    cout << "pa : " <<pa->val << "\tpb : " << pb->val << "\tpc: " << pc->val << endl;

    cout << "Amend pc；" << endl;

    pc->setVal(18);

    cout << "pa : " <<pa->val << "\tpb : " << pb->val << "\tpc: " << pc->val << endl;

    cout << "Init pd with Address :" << pd << endl;

    pd = pa;

    cout << "After : pd = pa......pdget Adress: " << pd << endl;

    cout << "The Value of pd :"<< pd->val << endl;

    return 0;

}

//输出结果

Value:a =11    b = 11    c = 11

address:&a:0x70fe04    &b0x70fe00    &c0x70fe04

 

ObjectTest:

Value:ta.val= 12    tb.val = 12    tc.val = 12

Address:0x70fdf0    0x70fde0   0x70fdf0

Amend ta

ta.val =13    tb.val = 12    tc.val = 13

Address:0x70fdf0    0x70fde0   0x70fdf0

Amend tb

ta.val =13    tb.val = 15    tc.val = 13

Address:0x70fdf0    0x70fde0   0x70fdf0

Amend tc

ta.val =21    tb.val = 15    tc.val = 21

Address:0x70fdf0    0x70fde0   0x70fdf0

Init tdwith Address :0x70fdd0

After td= ta ......td get Address :  0x70fdd0

The valin td :21

 

 

ObjectPointer Test:

Value:

pa :11        pb :11        pc : 11

Address :

0x1f14a0    0x1f14a0   0x1f14a0   

Amend pa:

pa :14        pb :14        pc : 14

Amend pb:

pa :17        pb :17        pc : 17

Amend pc；

pa :18        pb :18        pc : 18

Init pdwith Address : 0x1f14c0

After :pd = pa......pd get Adress: 0x1f14a0

The Valueof pd :18


//输出结果

Value:a =11    b = 11    c = 11

address:&a:0x70fe04    &b0x70fe00    &c0x70fe04

 

ObjectTest:

Value:ta.val= 12    tb.val = 12    tc.val = 12

Address:0x70fdf0    0x70fde0   0x70fdf0

Amend ta

ta.val =13    tb.val = 12    tc.val = 13

Address:0x70fdf0    0x70fde0   0x70fdf0

Amend tb

ta.val =13    tb.val = 15    tc.val = 13

Address:0x70fdf0    0x70fde0   0x70fdf0

Amend tc

ta.val =21    tb.val = 15    tc.val = 21

Address:0x70fdf0    0x70fde0   0x70fdf0

Init tdwith Address :0x70fdd0

After td= ta ......td get Address :  0x70fdd0

The valin td :21

 

 

ObjectPointer Test:

Value:

pa :11        pb :11        pc : 11

Address :

0x1f14a0    0x1f14a0   0x1f14a0   

Amend pa:

pa :14        pb :14        pc : 14

Amend pb:

pa :17        pb :17        pc : 17

Amend pc；

pa :18        pb :18        pc : 18

Init pdwith Address : 0x1f14c0

After :pd = pa......pd get Adress: 0x1f14a0

The Valueof pd :18


//返回指针

/*
 * return 地址
 */
#include <iostream>
using namespace std;
int *set(int *p)
{
    return new int(110);
}
int main()
{
    int a = 11;
    int *pa = &a;
    cout << "pa 的地址是：" << pa << endl;
    cout << "*pa = " << *pa << endl << endl;


    pa = set(pa);
    cout << " set ....." << endl;
    cout << "pa 的地址是：" << pa << endl;
    cout << "*pa = " << *pa << endl ;
    return 0;
}


// 输出结果

pa 的地址是：0x70fe34
*pa = 11


 set .....
pa 的地址是：0x7f14a0
*pa = 110

菜地里的程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++、Java的函数传参分析
HarryWg的博客
04-14 116
对于基本类型，C++与Java均为传值调用，那么对于对象传参，二者是否有不同的机制呢。 C++函数传参分析 #include<iostream> class Dog { private: int id; //狗狗id public: Dog(int id_) //有参构造函数 { std::cout << "Constructing Dog" << std::endl; this->id = id_;
C++与Java之函数参数传递
zhm_xd的专栏
08-11 144
学过编译原理以后，我们都知道函数的参数传递有两种，分别是值传递和引用传递（又叫地址传递）。 值传递，函数只调用时，只是将实参的值拷贝到形参中，在函数里面操作都是针对形参，而在函数调用完毕以后形参所占的空间会被释放，这样在调用前后不会对实参的值产生任何影响。 引用传递，又叫地址传递。顾名思义，那就是在函数调用时，将实参的地址传给形参，换句话说就是实参和形参...
C/C++与JAVA函数方法传值原理分析
QingKing520的博客
10-22 711
C/C++与JAVA函数方法传值原理分析
JAVA之等号、传类对象参数与c++的区别
473687880
09-03 157
在JAVA中用等号对类对象进行赋值，实际上操作的是对象的地址。 eg： package MyText; class ClassA { int value; public void seta(int value) { this.value = value; } public void show() { System.out.println("the value:" + ...
Java与C++函数参数传递比较
乐在其中/Leo在其中
12-06 132
学好C++，为祖国四化做贡献。 简言之：Java都是值传递(pass-by-value)，而C++中包括值传递(pass-by-value)和引用传递(pass-by-reference)。 先说Java，先做几点说明： 在Java中，无非就是两种类型，即基本类型和从Object继承下来的对象类型，而对象类型又包括String这种一旦初始化就不可改变内容的类型和BufferString这种可...
java及C++中传值传递、引用传递和指针方式的理解
09-04
值传递与Java类似，只是C++允许对基本数据类型进行直接复制。引用传递类似于Java中的引用，但它不像Java那样创建引用副本，而是直接提供原始对象的别名。这意味着对引用参数的任何修改都会影响原始对象，如`ByRef`...
java及C++中传值传递、引用传递和指针方式的理解.docx
01-19
本文将深入探讨Java与C++这两种广泛使用的编程语言中参数传递的方式，包括值传递、引用传递以及C++中的指针传递，并通过具体的代码示例来帮助理解这些概念。 #### 值传递 值传递是最简单的参数传递方式之一，它指...
对Java中传值调用的理解分析
09-03
在Java编程语言中，"传值调用"是指在函数或方法调用时，参数的值被复制并传递到函数内部。这意味着，当一个变量作为参数传递时，函数内部的操作不会影响到函数外部的原始变量。这个概念与C++中的"传引用调用"有所...
Java的引用和函数参数传递
03-17
### Java的引用与函数参数传递详解 #### 一、Java中的引用基础 在Java中，对象的引用扮演着类似于其他编程语言（如C/C++）中指针的角色，但是Java的引用比传统的指针更加安全且易于管理。这是因为Java的设计者们...
23.Java对象作为参数传递是传值还是传引用1
08-03
在Java编程语言中，关于Java对象作为参数传递时的行为，存在一种常见的误解。许多人认为对象是按引用传递，而实际上，Java总是按值传递，包括对象。这里的“值”指的是对象的引用，而不是对象本身。这与C++或C#等...
对比C++理解Java函数传参数的方式
yasi_xi的专栏
05-06 700
《总结java方法(函数)传值和传引用的问题》帖子
Java调用C++库dll文件接口(JNI)回传int参数(引用)
jszj的专栏
07-29 1287
大
java 调用c++函数指针
最新发布
hongyawx的专栏
07-05 232
/ 获取回调接口的类和方法ID。// 调用回调方法获取结果。// 模拟的指针函数。
浅谈C++函数的参数（参数默认值与Java中的实现）
懒人的技术笔记
03-14 4141
函数参数的求值顺序 当一个函数带有多个参数时，C++语言没有规定在函数调用时实参的求值顺序。而编译 器根据对代码进行优化的需要自行规定对实参的求值顺序。有的编译器规定自左至右， 有的编译器规定自右至左，这种对求值顺序的不同规定，对一般参数来讲没有影响。但 是，如果实参表达式中带有副作用的运算符时，就有可能产生由于求值顺序不同而造成 了二义性。例如：int z = add_int(++x, x+y);,这样，在不同的编译器就有可能生产 不同的结果。 设置参数的默认值 在C++语言中，允许在函数的说明或定义时给
c++调java 传参_浅析C++函数参数与Java传递比较
weixin_36080429的博客
03-03 173
对于C++函数参数与Java传递比较的问题，相信这是许多技术人员和一些开发人员的头疼的一块心病，看完本篇文章您就会了解什么是Java值传递，什么是C++函数参数值传递。先说Java，先做几点说明：在Java中，无非就是两种类型，即基本类型和从Object继承下来的对象类型，而对象类型又包括String这种一旦初始化就不可改变内容的类型和BufferString这种可以初始化后可以改变内容的类型。然...
深入理解ClassLoader工作机制（jdk1.8）
热门推荐
小张的专栏
08-05 4万+
ClassLoader 顾名思义就是类加载器,ClassLoader 作用： 负责将 Class 加载到 JVM 中 审查每个类由谁加载（父优先的等级加载机制） 将 Class 字节码重新解析成 JVM 统一要求的对象格式 类加载时机与过程 类从被加载到虚拟机内存中开始，直到卸载出内存为止，它的整个生命周期包括了：加载、验证、准备、解析、初始化、使用和卸载这7个阶段。其中，验证、准备和解...
C++与java中的参数传递
重剑无锋
08-18 1310
  Java传值与传引用。对基本数据类型传递值，对象则传引用。传递对象时，若在被调函数体内改变了对象的值，那么在调用函数内对象的值也会改变。试试下面一段代码。void testValue(int i)    ...{        i=100;    }    void testInteger(Integer i)    ...{        i=new Integer(200);   
android jni 结构体_JNI 返回结构体参数 android
weixin_28730927的博客
01-26 519
如何使用JNI的一些基本方法和过程在网上多如牛毛，如果你对Jni不甚了解，不知道Jni是做什么的，如何建立一个基本的jni程序，或许可以参考下面下面这些文章:利用VC++6.0实现JNI的最简单的例子JNI入门教程之HelloWorld篇SUN JNI Tutorial这些资料的例子中，大多数只是输入一些简单的参数，获取没有参数。而在实际的使用过程中，往往需要对参数进行处理转换。才可以被C/C++...
Java与C++参数传递方式对比
bsbhenry的专栏
12-06 396
1 Java Java中方法（函数）的参数传递只有按值调用一种方式。只是在方法内部产生了一个参数的拷贝。 方法参数分为两种： 1.基本数据类型。方法无法修改参数的值。 2.对象引用。假设一个类Employee有一个raiseSalary的方法，在tripleSalary函数中调用该方法。 public static void tripleSalary(Employee x){ ...
Java语言特性与传值机制
它与C/C++有密切的关系，语法上有很多相似之处，但Java更加注重安全和方便的内存管理。" 在Java编程中，引用类型参数的传值是一个关键概念。不同于基本类型的传值方式，Java中的引用类型参数传递时，实际上是传递了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值