-
值传参,值的引用传参,指针传参(两类),指针的引用传参(两类)
2020-05-12 16:31:171、值传参,对形参的任何操作都不会对实参产生影响 1.1:值传参方法 //值传参 void NoChangeValue(int v) { printf("值传参修改前的值 = %d\n", v); v = 10; printf("值传参修改...1、值传参,对形参的任何操作都不会对实参产生影响
1.1:值传参方法
//值传参 void NoChangeValue(int v) { printf("值传参修改前的值 = %d\n", v); v = 10; printf("值传参修改后的值 = %d\n", v); }
1.2:主方法
void main() { int n = 1; printf("\n----------------------NoChangeValue------------------------------------\n\n"); printf("调用前的值是 = %d\n", n); printf("\n------------start---------\n\n"); NoChangeValue(n); printf("\n------------end-----------\n\n"); printf("调用后的值 = %d,还是原值\n", n); }
1.3:运行结果
1.4:解释
当主程序调用一个方法时,会产生一个栈帧。在栈帧中,包含方法的形参、方法的局部变量。执行方法时,会将实参的值赋值给栈帧中的形参。因此:对形参的操作不会影响到实参。
2、值的引用传参,对形参的任何操作都会对实参产生影响
2.1:引用传参方法
void ChangeValue(int &v) { printf("值传参修改前的值 = %d\n", v); v = 10; printf("值传参修改后的值 = %d\n", v); }
2.2:主方法
void main(){ int n = 2; int* p = &n; printf("\n----------------------ChangeValue------------------------------------\n\n"); printf("调用前的值是 = %d\n", n); printf("\n------------start---------\n\n"); ChangeValue(n); printf("\n------------end-----------\n\n"); printf("调用后的值是 = %d,不再是原值\n", n); }
2.3:运行结果
2.4:解释
引用相当于是外部变量的别名,实际操作的就是该变量,即在函数内对该变量进行修改的话,在外部该变量也会相应被修改。
3、指针传参第一种,直接改变指向的值
3.1:指针传参方法
void ChangePtrValue(int* p){ printf("分配内存前p的地址 = %d \t 分配内存前p指向的地址 = %d \t 分配内存前p指向地址上的数值 = %d\t\n", &p,p,*p); *p = 3;//直接改变指向的值 printf("分配内存后p的地址 = %d \t 分配内存后p指向的地址 = %d \t 分配内存后p指向地址上的数值 = %d\t\n", &p,p,*p); }
3.2:主方法
void main(){ int n = 2; int* p = &n; printf("----------------------ChangePtrValue------------------------------------\n\n"); printf("方法调用前p的地址 = %d \t 方法调用前p指向的地址 = %d \t 方法调用前p指向地址上的数值 = %d\t\n", &p,p,*p); printf("\n------------start---------\n\n"); ChangePtrValue(p); printf("\n------------end-----------\n\n"); printf("方法调用后p的地址 = %d \t 方法调用后p指向的地址 = %d \t 方法调用后p指向地址上的数值 = %d\t\n", &p,p,*p); }
3.3:运行结果
3.4:解释
第一种是直接把值存放到指针存放的地址空间中,即:*p=10
4、指针传参第二种,通过改变指针指向的地址空间,来间接的改变指针指向的值(其实并不可以改变)
4.1:指针传参方法
//不可改变指针所指向的地址 void NoChangePtrAddress(int* p) { printf("分配内存前p的地址 = %d \t 分配内存前p指向的地址 = %d \t 分配内存前p指向地址上的数值 = %d\t\n", &p,p,*p); int n = 3; p = &n; printf("分配内存后p的地址 = %d \t 分配内存后p指向的地址 = %d \t 分配内存后p指向地址上的数值 = %d\t\n", &p,p,*p); }
4.2:主方法
void main(){ int n = 2; int* p = &n; printf("----------------------NoChangePtrAddress------------------------------------\n\n"); printf("方法调用前p的地址 = %d \t 方法调用前p指向的地址 = %d \t 方法调用前p指向地址上的数值 = %d\t\n", &p,p,*p); printf("\n------------start---------\n\n"); NoChangePtrAddress(p); printf("\n------------end-----------\n\n"); printf("方法调用后p的地址 = %d \t 方法调用后p指向的地址 = %d \t 方法调用后p指向地址上的数值 = %d\t\n", &p,p,*p); }
4.3:运行结果
4.4:解释
第二种是在方法中通过将变量的地址存放到形参指针中,使形参指针指向另一个地址空间,间接的修改形参指针指向的值。在方法调用过程生成的栈帧中,该指针是局部的,是因为它只是实参指针的一个拷贝,对局部变量 的修改并不会改变实际指针。因此:不会像指针传参第一种一样。
5、指针引用传参第一类,仅会改变指针指向的地址(即改变指针的内容),而使得指针指向的值出现非法现象
5.1:指针传参方法
//可改变指针所指向的地址 void ChangePtrAddress(int* &p) { printf("分配内存前p的地址 = %d \t 分配内存前p指向的地址 = %d \t 分配内存前p指向地址上的数值 = %d\t\n", &p,p,*p); int n = 3; p = &n;//改变指针指向的地址空间 printf("分配内存后p的地址 = %d \t 分配内存后p指向的地址 = %d \t 分配内存后p指向地址上的数值 = %d\t\n", &p,p,*p); }
5.2:主方法
void main(){ int n = 2; int* p = &n; printf("----------------------NoChangePtrAddress------------------------------------\n\n"); printf("方法调用前p的地址 = %d \t 方法调用前p指向的地址 = %d \t 方法调用前p指向地址上的数值 = %d\t\n", &p,p,*p); printf("\n------------start---------\n\n"); NoChangePtrAddress(p); printf("\n------------end-----------\n\n"); printf("方法调用后p的地址 = %d \t 方法调用后p指向的地址 = %d \t 方法调用后p指向地址上的数值 = %d\t\n", &p,p,*p); }
5.3:运行结果
5.4:解释
之所有会出现非法,是因为int n = 3;p = &n;n是一个局部变量,当方法调用结束时,会对该空间进行释放,因此出现不符合实际的情况。而指针指向的地址发生改变(虽然该地址不存在),这是因为在引用传参中,对形参的操作就是对实参的操作。
6、指针引用传参第二类,如同指针传参第一种,直接改变指向的值(即使用*p=10;)。再在此不在多讲。
7、结论
若要改变值实参,通过值引用传参、或通过指向其地址的指针来进行指针传参。
若要改变指针中的内容(即指针指向的地址),使用指针引用传参第一类。
若要改变指针指向地址空间的内容,使用指针引用传参第二类或指针传参第一类。 -
一分钟学java之引用传参和数值传参
2019-09-11 07:30:00一个人学Java太孤独,小伙伴陪你一起学哦也可以加小刀微信,进群一起学习best396975802结合视频所述,引用传参和值传参最大的区别就是,在方法内,如果对传入的参数修改会影响到外面...一个人学Java太孤独,
小伙伴陪你一起学哦
也可以加小刀微信,进群一起学习
best396975802
结合视频所述,引用传参和值传参最大的区别就是,在方法内,如果对传入的参数修改会影响到外面的,就是引用传参,如果影不到外面的,就是值传参
小刀更想和大家聊的是下面这些
方法中代码层级的划分
在现在开发中,在一个方法中可能要很写多行,各种if-else判断,然后拿到返回值后再进行判断等等,
其实我们可以把项目做一个划分:
- 卫语句
所谓卫语句,即起到保卫作用的代码,用以检验入参,返回值,一旦发现不满足要求的,就退出逻辑
if(null == param){ return BaseResponse.fail("param is null"); }
- 定义最终的返回值
然后定义最终的返回值,在下面的方法中,一步一步的对这个返回值进行设值,直至最后可以返回,如下所示
AccountDTO dto = new AccountDTO(); String name = "程序员学习大本营"; //以前的写法 dto.setName(name); //可以尝试的写法 richName(dto,name); public void richName(AccountDTO dto , String name){ if(null == name){ throw new BusinessException("name is null"); } dto.setName(name); }
- 最后的返回
返回开心就好了,, return dto;
创作不易,喜欢的话,
扫一下下面的二维码,
给小刀在酷暑带来一丝丝清凉吧
或者点个在看表示你对公众号的支持吧
谢谢你哟~
END
小哥哥小姐姐,
点个在看再走吧~(づ ̄3 ̄)づ╭❤~
-
C++ 引用传参
2018-04-04 18:18:12在C++中,引用的表示方法与指针相似,只是用&代替了*。引用(reference)是c++对c语言的重要扩充。引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。引用的声明方法:类型标识符...在C++中,引用的表示方法与指针相似,只是用&代替了*。引用(reference)是c++对c语言的重要扩充。引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。引用的声明方法:类型标识符 &引用名=目标变量名;
引用作为变量的别名,在一些场合可以代替指针;
引用相对指针来说有更好的可读性和实用性;
引用本质是对象的一个常指针
void function(int &a) { a=100; } //引用转化为指针的函数 void function(int * const a) { *a=100; }
1. 单独定义引用时,必须要初始化;
int &a;//错误; 引用变量 "a" 需要初始值设定
2. 改变引用变量的值,同时也会改变原变量
int a = 0; int &b = a; b = 100; cout << a;//输出:100
3.函数返回“非静态”栈变量的引用,栈空间会被回收,不能作为其它变量的初始值
int getVal1()//返回值本身 { int a = 100; return a; } int& getVal2()//返回引用 { int a = 100; return a; } int* getVal3()//返回指针 { int a = 100; return &a; } int main() { int a1 = getVal1(); int a2 = getVal2();//使用int去接收,打印:100 int &a22 = getVal2();//使用引用接收,打印:随机地址值 int *a3 = getVal3();//同a22 return 0; }
4.函数返回“静态”栈变量引用,输出正常;因为static修饰的变量,存放在静态存储区,具备持久性;
int getVal1()//返回值本身 { static int a = 100;//static 修饰的局部变量;注意:Java不支持这种写法; return a; } int& getVal2()//返回引用 { static int a = 100; return a; } int* getVal3()//返回指针 { static int a = 100; return &a; } int main() { int a1 = getVal1(); int a2 = getVal2();//使用int去接收,打印:100 int &a22 = getVal2();//使用引用接收,打印:100 int *a3 = getVal3();//同a22 return 0; }
5.基本数据类型传参
//交换了拷贝的值,不能交换实参本身的值; 与Java中效果一样 void swap0(int a, int b) { int c = a; a = b; b = c; } void swap(int& a, int & b) { int c = a; a = b; b = c; } void swap(int* a, int * b) { int c = *a;//注意: 不能定义为 int *c=a;去交换 *a = *b; *b = c; } int main() { int a = 1, b = 2; printf("swap1交换前,a:%d,b:%d\n", a, b); swap1(a,b); printf("swap1交换之后,a:%d,b:%d\n",a,b); printf("swap2交换前,a:%d,b:%d\n", a, b); swap2(a, b); printf("swap2交换之后,a:%d,b:%d\n", a, b); printf("swap3交换前,a:%d,b:%d\n", a, b); swap3(&a, &b); printf("swap3交换之后,a:%d,b:%d\n", a, b); } //输出 swap1交换前,a:1,b:2 swap1交换之后,a:1,b:2 swap2交换前,a:1,b:2 swap2交换之后,a:2,b:1 swap3交换前,a:2,b:1 swap3交换之后,a:1,b:2
6. 复杂数据类型传参
在Java中:
static class Person{ private int age; public Person(){} public Person(int age){ this.age=age; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } public static void edit1(Person p){ p.setAge(100); } public static void main(String args[]){ Person p1=new Person(11); System.out.println("edit之前,p1:"+p1.getAge()); edit1(p1); System.out.println("edit之后,p1:"+p1.getAge()); }
输出:
=>对象的形参与实参指向同一块内存;
在C++中:
输出:#include <iostream> using namespace std; class Person { private: int age; public: int getAge() { return age; } void setAge(int age) { this->age = age; } Person() {} Person(int age) { this->age = age; } }; void edit1(Person p) { p.setAge(100); } void edit2(Person &p) { p.setAge(100); } void edit3(Person *p) { p->setAge(100); } int main() { Person p1(11); printf("edit1之前,p1:%d\n", p1.getAge()); edit1(p1); printf("edit1之后,p1:%d\n", p1.getAge()); p1.setAge(11); printf("edit2之前,p1:%d\n", p1.getAge()); edit2(p1); printf("edit2之后,p1:%d\n", p1.getAge()); p1.setAge(11); printf("edit3之前,p1:%d\n", p1.getAge()); edit3(&p1); printf("edit3之后,p1:%d\n", p1.getAge()); system("pause"); return 0; }
可以看出edit1,类似Java的写法,在Java中可以更改p1对象的值,在c++中无效;
原因:
* C++中声明对象 Person p; 会申请一块新内存,去初始化Person对象;
* Java中声明对象 Person p; 只声明不赋值,则只会在内存的栈区创建对象的引用,并没有在堆区申请对象的空间;
=> C++中的引用传递类似Java中的复杂对象的传递方式;
-
引用传参换值
2019-09-28 16:44:15@Description: 方法传参 */ public class TestCon { public static void swap(MyTest a, MyTest b) { int tmp = a.getNum(); a.setNum(b.getNum()); b.setNum(tmp); } public static void main...package com.fcy; /** * * @Description: 方法传参 */ public class TestCon { public static void swap(MyTest a, MyTest b) { int tmp = a.getNum(); a.setNum(b.getNum()); b.setNum(tmp); } public static void main(String[] args) { MyTest a = new MyTest(3); MyTest b = new MyTest(5); TestCon.swap(a, b); System.out.println(a.getNum() + " " + b.getNum()); } } class MyTest { int Num; public MyTest(int Num){ this.Num = Num; } public int getNum() { return Num; } public void setNum(int tmp) { Num = tmp; } }
-
python引用传参_【134】python 之传参
2020-12-20 13:48:38内容目录(原文见公众号python宝)一、Python的函数传递二、python类方法外部传参一、Python的函数传递a=1deffun(a):print("函数里",id(a))a=2print("赋值后",id(a),id(2))print("函数外",id(a),id(1))fun(a)print(a)... -
对象引用 方法传参 值传递 引用传递 易错点 MD
2018-11-23 23:38:00Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao ...对象引用 方法传参 值传递 引用传递 易错点 目录 目录概念方法传递案... -
方法的传参
2017-05-25 14:55:20这段代码的输出值是goodandgbc很明显,传入的String没有被改变,而传入的char数组的值却被改变了。首先对于传参来说,区别在在于数据类型, 一、对于基本数据类型来说是不能修改基本...二、对于对象引用类型的传参对于 -
引用类型方法传参的一点领悟
2017-03-10 16:15:55引用类型方法传参的一点领悟下午碰到一道笔试题,是非常常见的关于引用类型方法传参的题目。代码如下:public class Demo4 { public static void main(String[] args) { StringBuilder a = new StringBuilder("a")... -
C#调用C++ dll时,结构体引用传参的方法
2013-10-29 14:52:00写了一个C++的LogLog Logit 四参数等算法的接口dll,给C#调用,但是发现传参有问题 如 extern "C" _declspec(dllexport) bool TestFunc(EnumMethod eMethod, unsigned int uiPoints, const double *parA, const ... -
Java通过引用类型进行方法传参
2019-09-27 20:25:25通过引用类型进行方法传参需要知道如下几点: 当参数是基本数据类型时,方法不能修改实际参数的值。 当参数是引用类型时,方法通过地址引用改变了实际参数对象的内容。 基本引用类型有:类、接口、数组。 以下... -
java方法间传参问题
2019-03-05 11:00:15java方法间传参问题 有些人会迷惑java方法传参的时候有时候会改变原来的值,有时候不会,这是为什么呢?其实这是要分很多种情况的:原始类型,引用类型,不可变类型,改变值,改变地址。 看一些简单的例子 ... -
方法、传参
2017-07-18 20:27:48package myproject;... * 引用数据类型 * void(空) * 方法名(标识符) * 见名知意 * 参数列表 * 一般根据自己的业务需求,可有可无 * 形参列表:就是说明了这个方法在调用的时候需要传入的参数 -
引用传参和static修饰符
2016-03-30 14:22:55类似引用传递,并不是就是引用传递 实际传送的是实参的一个地址的副本,所以参数的对象传递的是地址 static修饰的变量和方法都是属于整个类的,而不是单独属于哪一个变量的,是这个类所有对象的共有的一个属性变量 -
JAVA值传递和引用传参。
2018-03-16 19:08:04基本数据类型 整型:byte,short,int,long浮点型:float,double字符型:char布尔型:boolean引用数据类型 数组类接口方法的参数分为实际参数,和形式参数。形式参数:定义方法时写的参数。实际参数:调用方法时... -
方法传参中的值类型和引用类型
2019-07-25 17:45:30按引用传参,方法修改形参,通常实参也会被修改 按值传参,方法修改形参,实参不会被修改 -
java 对象引用 值引用_为什么说Java对象引用传参是按值调用的
2021-02-27 11:12:57Java在函数传参时会发现Java方法在没返回值情况下可能无法达到预期的效果。例如Java//将两个对象互换public class Expelor {public static void main(String[]arge) {//创建两个Empee实例对象Empee firstMan=new ... -
方法传参
2017-09-16 23:09:00关于方法传参: (参数也叫 参变量 ,它是专属于方法体的局部变量!) 首先我想先说一个结论:基本数据类型作形参时,实参向形参传递的是值;引用数据类型作形参时传递的是 对象。(其实传递都是值,具体可... -
一文读懂之方法调用传参
2019-11-19 20:51:43方法调用传参按照数据类型分为两种: 数据类型分为两大类: 基本数据类型和引用数据类型(类,接口,数组) 一、基本数据类型传参 例: public class Test { public static void main(String[] args) { //交换两个... -
C&C++关于数组的定义,引用传参问题
2017-02-07 14:30:12C++关于数组的定义,引用传参问题 (1)数组的定义 #define maxSize 50 static int length = 10; 正确定义方法:int array[maxSize]; 错误定义方法:int array[length]; 分析:数组的 [ ]中只能放 -
java 方法传参是引用传递还是值传递
2017-11-30 16:10:31java 方法传参是引用传递还是值传递 -
java 之方法调用 方法传参 值传递还是引用传递字节码
2019-04-05 01:06:58NULL 博文链接:https://m635674608.iteye.com/blog/1513061 -
为什么说Java对象引用传参是按值调用的
2020-04-12 15:26:40Java在函数传参时会发现Java方法在没返回值情况下可能无法达到预期的效果。 例如 Java //将两个对象互换 public class Expelor { public static void main(String[]arge) { //创建两个Empee实例对象 Empee ... -
java中方法中传参时基本类型和引用类型的理解
2018-02-07 15:23:52package rhapp_service; public class TestZhouy { public static void main(String[] args) { ... * 即将本身的值赋值给方法中的形参中,方法中对形参操作,不影响之前的值。 */ int a = -
Java中方法的传参问题
2021-01-05 08:40:06值传递和引用传递 ...引用传递(call ),指的是调用方法时,传入的是实参的变量地址 注意,基本数据类型也是有地址的 这样做的结果,方法改变的是实参本身的值,原来实参的值会跟着变化 Java到底是哪 -
面向对象、值与引用传参、变量与堆栈
2019-09-29 16:34:08根据需求,分析解决该需求所需要的步骤,利用函数(方法)将这些步骤一一实现,使用时在进行依次调用。 面向对象: 把需求分解成一个个的功能,利用函数(方法)将这些功能一一实现,使用时调用功能。 在面向对象...