精华内容
下载资源
问答
  • c++类的对象作为方法参数(即函数参数

    千次阅读 多人点赞 2019-09-12 17:13:03
    c++类的对象作为参数传递时,有三种传递方式 #include <iostream> using namespace std; //求圆的面积 class Mycircle{ public: double r; double s; public: double getR(){ return r; } void setR...

    c++类的对象作为参数传递时,有三种传递方式

    #include <iostream>
    
    using namespace std;
    
    //求圆的面积
    class Mycircle{
    
    public:
        double r;
        double s;
    public:
        double getR(){
            return r;
        }
        void setR(double a){
            r = a;
    
        }
        double getS(){
            s = 3.14*r*r;
            return s;
        }
    
    
    };
    //类做函数参数有三种方法
    /*第一种,最常用(这种适用于普通类型变量传值,当对象作为函数参数时候用引用形式,即第二种,减少内存开销)
    
    void printCircle(Mycircle mc){
        cout<<"半径是"<<mc.getR()<<endl;
    }
    
    */
    
    //第二种,引用方式(与第一种的调用方法一样,直接传参数,这是当传递的参数是一个对象时使用引用方式传递)
    void printCircle(Mycircle &mc){
        cout<<"半径是"<<mc.getR()<<endl;
    }
    //第三种,指针(需要传入一个地址)
    void printCircle(Mycircle *mc){
        cout<<"半径是"<<mc->getR()<<endl;
        /*不能使用mc.getR()或mc.r,与结构体不一样(结构体既可以A.B,也可以A->B,等价的),但对象调用方法是
        A.B,对象指针调用方法是A->B。
        简单来说,“->”的前面一定是一个“指向结构体的指针”或“对象指针”,后面是结构或对象的一个"成员" 。
        如有:A->B,则可以肯定A是一个结构体指针或类的对象指针,而B是A中的一个成员。
        类封装了变量和方法,更丰富
        */
    }
    int main()
    {
        Mycircle c;
        c.setR(2.4);
        cout << "面积是"<<c.getS() << endl;
        printCircle(&c);//指针方式
        printCircle(c);//引用方式
        //printCircle(c);//常用方式,这里注释掉,因为测试会与引用方式重载冲突
        return 0;
    }
    
    展开全文
  • c#中对象作为方法参数传递引用传递,值传递这本是一个很简单的知识点,但是我们在实际开发过程中还是蛮容易踩到这个 坑,尤其是在维护他人代码。逻辑比较复杂的时候,容易出错,哈哈,警醒一下。 如图所示,对象...
     c#中对象作为方法参数传递引用传递,值传递这本是一个很简单的知识点,但是我们在实际开发过程中还是蛮容易踩到这个
     坑,尤其是在维护他人代码。逻辑比较复杂的时候,容易出错,哈哈,警醒一下。
    

    直接上图
    如图所示,对象为引用传递,方法中会改变实际的对象的值。
    引用传递相当于是对引用对象地址的传递,期间改变值,在方法出来之后,存在对应地址的值是会发生变化的。值传递,只是传值不会方法结束之后是不会改变值的。
    值传递变成引用传递,加上ref就行。string是引用类型,string按值传递的效果与值类型按值传递效果一样,string在这里比较特殊。
    引用传递不改变对象的值,其中一个方法是在方法中重新new一个对象,然后赋值,这样的话,就会在方法中重新开辟一个新的地址,来存放这些值,原先传入的参数不改变其地址上存入的值
    一句话总结,引用传递是传的是本身,值传递传的是个副本。

    展开全文
  • 当一个对象实例作为一个参数被传递到方法中时,参数的值就是该对象引用的一个副本。指向同一个对象对象的内容可以在被调用的方法中改变,但是对象的引用(不是引用的副本)是永远不会改变的。 Java参数:...

    问:当一个对象被当做参数传递到一个方法后,此方法可改变这个对象的属性,并返回变化后的结果,那么这里到底是值传递还是引用传递?

           答:是值传递。在java语言中只有值传递参数;当一个对象实例作为一个参数被传递到方法中时,参数的值就是该对象引用的一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变,但是对象的引用(不是引用的副本)是永远不会改变的

           Java参数:不管是原始类型还是引用类型,传递的都是副本(有另外一种说法是传值,传值一般相对于传地址而言)

           若参数类型是基本数据类型,那么传过来的就是这个参数的一个副本,也就是这个原始参数的值,这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值

           若参数类型是引用类型,那么传过来的就是这个引用参数的副本,这个副本存放的是参数的地址,如果在函数中没有改变这个副本的地址,而是改变了地址中的值,那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址,如new了一个,那么副本就指向了新的地址,此时传入的参数还是指向原来的地址,所以不会改变原来的值

    基本数据类型参数传递:不改变值

            public static void test(int a){
    		a=20;
    	}
    	public static void main(String[] args) {
    		int a=10;
    		test(a);
    		System.out.println(a);
    	}
    

    结果为:10

    可变对象参数传递:改变值

        public static void test2(StringBuffer sb){
            sb.append("add");
        }
        public static void main(String[] args) {
            int a=10;
            StringBuffer sb = new StringBuffer();
            sb.append("init:");
            test2(sb);
            System.out.println(sb);
        }
    

    结果为:init:add

    封装对象作为参数传递,若在方法内修改属性值,则改变值

           由于在传入方法之前创建对象,是同一引用,所以会改变其对象内容

        public static void test3(A  bean){
            bean.setName("李四");
        }
    
        public static void main(String[] args) {
            A  bean = new A();
            bean.setName("张三");       
            test3(bean);
            System.out.println(bean.getName());
        }
     
        class A {
            private String name;
     
            public String getName() {
                return name;
            }
     
            public void setName(String name) {
                this.name = name;
            }
        }

    结果为:李四

    封装对象作为参数传递,若在方法内对象重新赋值,则改变值

           由于方法内的对象是重新创建的,因此引用不同,方法内对象改变并不会影响外面的对象内容

        public static void test4(A  bean){
            A bean2 = new A();
            bean2.setName("李四");
            bean = bean2;
            bean.setName("王犊子");
        }
    
        public static void main(String[] args) {
            A  bean = new A();
            bean.setName("张三");       
            test4(bean);
            System.out.println(bean.getName());
        }
     
        class A {
            private String name;
     
            public String getName() {
                return name;
            }
     
            public void setName(String name) {
                this.name = name;
            }
        }
     

    结果为:张三

    展开全文
  • // 对象作为方法参数和返回值传递 #import /*  事物名称:士兵soldier  属性:姓名 身高 体重  方法:打手枪 打电话    事物名称:手枪gun  属性:弹夹 型号  方法:上弹夹    事物名称:...

    //

    //  main.m

    //  对象作为方法的参数传递


    #import <Foundation/Foundation.h>

    /*

     事物名称:士兵soldier

     属性:姓名 身高 体重

     方法:打手枪 打电话

     

     事物名称:手枪gun

     属性:弹夹 型号

     方法:上弹夹

     

     事物名称:弹夹clip

     属性:子弹

     方法:上子弹

     

     事物名称:商店

     属性:

     方法:卖枪 卖弹夹

     */


    //子弹

    //添加标示和分割线

    #pragma mark - 弹夹

    @interface Clip : NSObject

    {

        @public

        int _bullet;

    }

    -(void)addBullet;

    @end

    @implementation Clip

    -(void)addBullet{

        _bullet = 10;

    }

    @end

    //

    #pragma mark -

    @interface Gun : NSObject

    {

        //@public

        //int _bullet;//子弹

        //Clip *clip;//优化 使用弹夹

    }

    //-(void)shoot:(NSString*)name;

    -(void)shoot2:(Clip *)clip :(NSString*)name;

    @end

    @implementation Gun

    //-(void)shoot:(NSString*)name{

    //    //判断是否有子弹

    //    if(_bullet>0){

    //        _bullet--;

    //        NSLog(@"%@打了一枪,%i",name,_bullet);

    //    }else{

    //        NSLog(@"没子弹了,换弹夹");

    //    }

    //}

    -(void)shoot2:(Clip *)clip :(NSString*)name{

        if(clip!=nil){//nil = null = 没有值

            if(clip->_bullet>0){

                clip->_bullet -=1;

                NSLog(@"%@打了一枪,%i",name,clip->_bullet);

            }else{

                NSLog(@"没有子弹了,添加子弹中");

                [clip addBullet];

            }

        }else{

            NSLog(@"没有弹夹,换弹夹");

        }

    }

    @end

    //士兵

    #pragma mark - 士兵

    @interface Soldier : NSObject

    {

        @public

        NSString *_name;

        double _height;

        double _weight;

    }

    //将对象作为方法的参数

    -(void)fire:(Gun *)gun :(Clip *)clip;

    @end

    @implementation Soldier

    -(void)fire:(Gun *)gun :(Clip *)clip{

        //NSLog(@"打了一枪");

        [gun shoot2:clip:_name];

    }

    @end

    #pragma mark - 商店

    @interface Shop : NSObject

    //对象作为返回值

    -(Gun *)buyGun:(int)money;

    -(Clip *)buyClip:(int)money;

    @end

    @implementation Shop

    -(Gun *)buyGun:(int)money{

        //通过new创建的对象存储在堆中,不会自动释放,在后面的代码中可以继续使用

        Gun * gun = [Gun new];

        return gun;

    }

    -(Clip *)buyClip:(int)money{

        Clip *clip = [Clip new];

        //卖弹夹加满子弹

        [clip addBullet];

        return clip;

    }

    @end

    #pragma mark - 主函数

    int main(int argc, const char * argv[]) {

        //创建商店

        Shop * shop = [Shop new];

        //创建弹夹

        Clip *clip = [shop buyClip:100];

        //创建枪

        Gun * gun = [shop buyGun:888];

        //创建士兵

        Soldier *soldier = [Soldier new];

        soldier->_name = @"wj";

        soldier->_height = 1.7;

        soldier->_weight = 85.5;

        //给士兵枪并枪射击

        [soldier fire:gun :clip];

        [soldier fire:gun :clip];

        [soldier fire:gun :clip];

        [soldier fire:gun :clip];

        return 0;

    }



    展开全文
  • java 对象作为方法参数传递

    万次阅读 2018-03-24 14:45:25
    说到对象作为方法参数传递的时候,大家都知道,当方法有返回值的时候,我们在其他方法定义一个接收他的对象就把他的值给获取到了,可是如果不定义对象接收呐?请看方法有返回值的情况下:这种情况下,打印出来的值...
  • StringBuilder对象作为方法参数

    千次阅读 2016-10-12 12:35:36
    运行结果说明在参数传递的时候,String类型的变量传递的过程是(以以上例子为例):先开辟一个方法储存区,并在方法储存区建立一个String类型的变量s1,再将类中的String类型变量s的值传递给s1,即进行操作s1=“java...
  • c++ 对象作为参数,指针作为参数,引用作为参数
  • Java之把String对象作为方法参数

    千次阅读 2016-03-13 16:52:23
    因为在java里,String是对象类型,作为参数肯定是引用传递。 ss参数完全符合引用传递的特点,很好理解。 下面来看一下String的构造函数实现,版本为jdk1.8: /** * Initializes a newly ...
  • Java对象作为参数传递给一个方法时,实际上传递的是这个对象引用的拷贝,被拷贝的引用和拷贝的引用指向同一个内存地址,即同一个对象 所以如果在方法中改变参数引用(拷贝的引用)指向的内存地址,对方法外的引用是...
  • 对象作为函数参数

    千次阅读 2017-02-21 21:02:14
    网上看见一段代码,是关于类对象作为函数的参数,其中有几点知识,贴出来大家一起学习。 直接来看代码: #include #include using namespace std; class people { private: char *name; int age; public: ...
  • c++对象作为函数参数

    千次阅读 2016-02-01 12:38:32
    c++对象作为函数参数也分为值传递和引用传递: 对象也可以作为函数的参数传递给函数,其转递方法与传递其他类型的数据一样,可采用值传递和地址传递两种方法。 值传递时是把对象的拷贝而不是本身传递给函数...
  • 对象作为参数传递给方法

    千次阅读 2018-12-06 16:55:06
    (2)定义一个类PassObject,在类中定义一个方法printAreas(),该方法的定义如下: public void printAreas(Cirlce c, int time) 在printAreas方法中打印输出1到time之间的每个整数半径值,以及对...
  • 今天想写一个多线程读取一个文本文件,需要fstream对象作为函数参数,出现了编译错误,查询了网上很多资料,在此汇总一下。  #include #include #include #include #include #include #include using ...
  • 将JSON对象作为参数方法

    千次阅读 2018-12-11 09:06:55
    这里一定要注意单引号和双引号的用法,否则就不能正确传递。原因是json内包含双引号。 return "&lt;div&gt;&...button class='btn btn-xs btn-warning btnEditSupervisorDuty ' onclick='...
  • JAVA在方法对象作为参数传递

    千次阅读 2018-02-23 17:42:35
    但是在java中,将方法A中的某个对象传递到方法B中进行修改后,再返回到A中,我们会发现对象在B中的修改在A中也有效。示例代码如下:有一个bean类:public class DemoBean { private String id; pu...
  • 相信玩过spring MVC的小伙伴肯定都尝试过,普通Object、String、String[]等基本类型的绑定方式了吧,下面我们介绍下List、Map需要绑定在对象作为参数的使用。话不多说,直接看代码:List需要绑定在对象上,而不能...
  • 今天在学习过程中,发现在C++使用对象作为函数参数进行传递时,实参向形参采用传值的方法进行传递,但是在函数中使用this指针,分别指向对象的数据成员,在子函数结束后返回main函数时,依然能够改变实参(对象)的...
  • Java中接口对象作为参数传递

    千次阅读 2016-05-23 18:56:14
    Java中接口对象作为参数传递(小例子)
  • 面试题: 在调用方法的时候,若要使方法改变参数的值,...用对象作为参数 C.以上都对 D.以上都不对 public class Test { public static void main(String[] args) { int a = 5; int[] arr = {1, 2, 3}; ...
  • 使用对象数组作为参数,只是将对象作为一个数组元素,其引用方法与基本数据类型的数组完全相同。但针对对象数组中的单个元素来讲,它又具有对象有属性和方法。 import java.util.Scanner; //学生类class Student{ ...
  • 用简单类型作为参数就是把参数个数和类型写死,改动影响大,如果使用对象传参,就很灵活,但传递对象的效率会差一点,这两种方式该如何取舍?
  • 在某些时候,我们可能需要反射技术来获取其方法来使用它,但是方法名,方法参数可能全都不知道 传入的参数具体是什么我们也不知道 例如,在使用切面的时候, ProceedingJoinPoint种getArgs也只是一个Object数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,669,080
精华内容 667,632
关键字:

对象作为方法的参数