精华内容
下载资源
问答
  • 1、值传参,对形参的任何操作都不会对实参产生影响 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太孤独,小伙伴陪你一起学哦也可以加小刀微信,进群一起学习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宝)一、Python的函数传递二、python类方法外部传参一、Python的函数传递a=1deffun(a):print("函数里",id(a))a=2print("赋值后",id(a),id(2))print("函数外",id(a),id(1))fun(a)print(a)...
  • Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao ...对象引用 方法传参 值传递 引用传递 易错点 目录 目录概念方法传递案...
  • 方法传参

    2017-05-25 14:55:20
    这段代码的输出值是goodandgbc很明显,传入的String没有被改变,而传入的char数组的值却被改变了。首先对于传参来说,区别在在于数据类型, 一、对于基本数据类型来说是不能修改基本...二、对于对象引用类型的传参对于
  • 引用类型方法传参的一点领悟下午碰到一道笔试题,是非常常见的关于引用类型方法传参的题目。代码如下:public class Demo4 { public static void main(String[] args) { StringBuilder a = new StringBuilder("a")...
  • 写了一个C++的LogLog Logit 四参数等算法的接口dll,给C#调用,但是发现传参有问题 如 extern "C" _declspec(dllexport) bool TestFunc(EnumMethod eMethod, unsigned int uiPoints, const double *parA, const ...
  • 通过引用类型进行方法传参需要知道如下几点: 当参数是基本数据类型时,方法不能修改实际参数的值。 当参数是引用类型时,方法通过地址引用改变了实际参数对象的内容。 基本引用类型有:类、接口、数组。 以下...
  • java方法传参问题

    2019-03-05 11:00:15
    java方法传参问题   有些人会迷惑java方法传参的时候有时候会改变原来的值,有时候不会,这是为什么呢?其实这是要分很多种情况的:原始类型,引用类型,不可变类型,改变值,改变地址。   看一些简单的例子 ...
  • 方法传参

    2017-07-18 20:27:48
    package myproject;... * 引用数据类型 * void(空) * 方法名(标识符) * 见名知意 * 参数列表 * 一般根据自己的业务需求,可有可无 * 形参列表:就是说明了这个方法在调用的时候需要传入的参数
  • 类似引用传递,并不是就是引用传递 实际传送的是实参的一个地址的副本,所以参数的对象传递的是地址 static修饰的变量和方法都是属于整个类的,而不是单独属于哪一个变量的,是这个类所有对象的共有的一个属性变量
  • 基本数据类型 整型:byte,short,int,long浮点型:float,double字符型:char布尔型:boolean引用数据类型 数组类接口方法的参数分为实际参数,和形式参数。形式参数:定义方法时写的参数。实际参数:调用方法时...
  • 引用传参方法修改形参,通常实参也会被修改 按值传参,方法修改形参,实参不会被修改
  • Java在函数传参时会发现Java方法在没返回值情况下可能无法达到预期的效果。例如Java//将两个对象互换public class Expelor {public static void main(String[]arge) {//创建两个Empee实例对象Empee firstMan=new ...
  • 方法传参

    2017-09-16 23:09:00
    关于方法传参:  (参数也叫 参变量 ,它是专属于方法体的局部变量!)  首先我想先说一个结论:基本数据类型作形参时,实参向形参传递的是值;引用数据类型作形参时传递的是 对象。(其实传递都是值,具体可...
  • 方法调用传参按照数据类型分为两种: 数据类型分为两大类: 基本数据类型和引用数据类型(类,接口,数组) 一、基本数据类型传参 例: public class Test { public static void main(String[] args) { //交换两个...
  • C&C++关于数组的定义,引用传参问题

    千次阅读 2017-02-07 14:30:12
    C++关于数组的定义,引用传参问题 (1)数组的定义  #define maxSize 50  static int length = 10;  正确定义方法:int array[maxSize];   错误定义方法:int array[length];  分析:数组的 [ ]中只能放
  • java 方法传参引用传递还是值传递
  • NULL 博文链接:https://m635674608.iteye.com/blog/1513061
  • Java在函数传参时会发现Java方法在没返回值情况下可能无法达到预期的效果。 例如 Java //将两个对象互换 public class Expelor { public static void main(String[]arge) { //创建两个Empee实例对象 Empee ...
  • package rhapp_service; public class TestZhouy { public static void main(String[] args) { ... * 即将本身的值赋值给方法中的形参中,方法中对形参操作,不影响之前的值。 */ int a =
  • Java中方法传参问题

    2021-01-05 08:40:06
    值传递和引用传递 ...引用传递(call ),指的是调用方法时,传入的是实参的变量地址 注意,基本数据类型也是有地址的 这样做的结果,方法改变的是实参本身的值,原来实参的值会跟着变化 Java到底是哪
  • 根据需求,分析解决该需求所需要的步骤,利用函数(方法)将这些步骤一一实现,使用时在进行依次调用。 面向对象: 把需求分解成一个个的功能,利用函数(方法)将这些功能一一实现,使用时调用功能。 在面向对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 998
精华内容 399
关键字:

方法引用传参