这节课我们来学习方法中的参数传递,在面向对象二中,我曾说过,参数也属于变量的一种,在c语言的学习时,同学们都学习过参数这个概念和用法,方法使用参数列表来传递变量的基本语法如下:
returnType  FunctionName(paraType1  paraName1,paraType2  paraName2,……)
{
   Function body;
}
其中的returnType是指方法的返回值,FunctionName指方法的标识符,paraType1指参数1的数据类型,paraName1是参数1的标识符,调用这种类型的方法的时候,必须传入与类型paraType1相符的参数值,并且传入的参数个数也必须相符,方法内部以参数名称paraName1来识别。
     在C#中,参数一共四种形式:分别是

参数类型值参数
引用参数--ref
输出参数--out
动态参数--parmas

他们都有什么区别呢?具体怎么用呢?我们现在就开始具体的讲解,
值参数


值参数就是参数的是值类型的,如 int   add(int i,int j){},i和j就是值参数,值参数很好理解,我们也经常用到,下面的代码实例主要是为了对比引用参数和输出参数的区别的实现两个数值交换的例子,请同学们体会它们的不同。

 1//定义一个交换两个数的值的一个方法Exchange
 2        //此处请注意,本方法使用了static关键字,原因是:根据我们类一所提到的,如果是实例方法(不加static关键字),
 3        //必须通过类的对象来调用,即使在同一个类中,加入static关键字后,静态成员就属于类的引用范围了,
 4        //因为在一个类中,所以不必类名.,在其他方法中直接就可以调用这个方法。对比下面的实例方法
 5        static void Exchange(int a, int b)
 6        {
 7            Console .WriteLine ();
 8            Console.WriteLine("值参数方法进来时,a={0}  b={1}", a, b);
 9            int c = 0;
10            c = a;
11            a = b;
12            b = c;
13            Console.WriteLine();
14            Console.WriteLine("经过值参数交换方法交换后,a={0}  b={1}", a, b);
15            Console.WriteLine();
16
17        }
18        //看这个实例方法,对照上一个方法,看在main方法中的调用是不同的,
19        //此方法必须通过Class2的对象s.来调用,而上一个方法是直接调用(因为在一个类中,省略了类名.来调用)
20        void Exchange1()
21        { 
22        }
23
24        static void Main()
25        {
26            //输入初值
27            Console.Write("请输入整数a=");
28            int a = int.Parse(Console .ReadLine());
29            //输入初值
30            Console.Write("请输入整数b=");
31            int b = int.Parse(Console.ReadLine());
32            
33            //观察1:经过交换后a和b的结果的变化,(方法结束时交换了a和b的值)
34            //2:对比下面的调用,记住静态方法调用的方式
35            //3:在main方法结束前,我们再次打印main中定义的a和b的值的变化(和初值相同)
36            Exchange(a,b);
37
38
39            //对比上面的调用,记住实例方法调用的方式
40            Class2 s = new Class2();
41            s.Exchange1();
42
43            //因为是值参数的传递方法,不会改变Main方法中的a的值,结果应该和初值相同
44            Console.WriteLine("采用值参数交换方法后,Main方法中现在为a="+a);
45            Console.WriteLine();
46            //因为是值参数的传递方法,不会改变Main方法中的b的值,结果应该和初值相同
47            Console.WriteLine("经过值参数交换方法后,Main方法中现在为b=" + b);
48        }
49
50       
51    }

运行结果

请输入整数a=2
请输入整数b=4

值参数方法进来时,a=2  b=4

经过值参数交换方法交换后,a=4  b=2

采用值参数交换方法后,Main方法中现在为a=2

经过值参数交换方法后,Main方法中现在为b=4
请按任意键继续. . .

可以看出值参数经过方法传递后,初值是不改变的,下面我们来看一下引用参数。

引用参数


如果方法的参数为数值类型时,则传递的方式主要分为两种:传值和传址。这两种方式最大的差异在于:当一个参数以传值的方式传递时,变量的值即使在方法中被改变,它本身还是维持一开始传入的值,我们刚才学习的值参数就是传值方式;而以传址方式传入的变量,当方法将其改变的时候,此变量的值便永远被更改,C#默认以传值方式传递参数,如果要使用传址方式传递,就需要用到下面我要说的理论。数值类型一律是以传值方式进行传递的,如果要改变这种行为,用传址方式传递参数,必须使用ref和out关键字进行修饰,当然如果参数本身就是引用类型的(string类型除外),不需要加ref和out关键字,他们的传递也是采用传址方式的.

使用ref关键字修饰的引用参数传递的方法书写格式如:static  int add(ref int i,ref int j){}  .在参数数值类型的前面加入ref修饰,在调用这个方法时,传入的参数前也必须加ref关键字,如:add(ref a,ref b);

下面我们上面的例子中Exchange方法中参数b变成ref形式,同学们来体会一下a作为值参数传值传递和b作为引用参数传址传递的区别:

 1class Class2
 2    {
 3        //定义一个交换两个数的值的一个方法Exchange
 4        //此处请注意,本方法使用了static关键字,原因是:根据我们类一所提到的,如果是实例方法(不加static关键字),
 5        //必须通过类的对象来调用,即使在同一个类中,加入static关键字后,静态成员就属于类的引用范围了,
 6        //因为在一个类中,所以不必类名.,在其他方法中直接就可以调用这个方法。对比下面的实例方法
 7        static void Exchange(int a, ref int b)
 8        {
 9            Console .WriteLine ();
10            Console.WriteLine("参数进来时,a={0}  b={1}", a, b);
11            int c = 0;
12            c = a;
13            a = b;
14            b = c;
15            Console.WriteLine();
16            Console.WriteLine("方法交换后,a={0}  b={1}", a, b);
17            Console.WriteLine();
18
19        }
20        //看这个实例方法,对照上一个方法,看在main方法中的调用是不同的,
21        //此方法必须通过Class2的对象s.来调用,而上一个方法是直接调用(因为在一个类中,省略了类名.来调用)
22        void Exchange1()
23        { 
24        }
25
26        static void Main()
27        {
28            //输入初值
29            Console.Write("请输入整数a=");
30            int a = int.Parse(Console .ReadLine());
31            //输入初值
32            Console.Write("请输入整数b=");
33            int b = int.Parse(Console.ReadLine());
34            
35            //观察1:经过交换后a和b的结果的变化,(方法结束时交换了a和b的值)
36            //2:对比下面的调用,记住静态方法调用的方式
37            //3:main方法结束前,我们再次打印main中定义的a和b的值的变化:a和初值相同,b与出方法值相同
38            Exchange(a,ref b);
39
40
41            //对比上面的调用,记住实例方法调用的方式
42            Class2 s = new Class2();
43            s.Exchange1();
44
45            //因为是值参数的传递方法,不会改变Main方法中的a的值,结果应该和初值相同
46            Console.WriteLine("采用值参数传递交换方法后,结果应该和初值相同,Main方法中现在为a=" + a);
47            Console.WriteLine();
48            //因为是引用ref参数的传递方法,会改变Main方法中的b的值,结果应该和出方法时的值相同
49            Console.WriteLine("经过引用参数传递交换方法后,结果应该和出方法时的值相同,Main方法中现在为b=" + b);
50        }   
51    }

运行结果

请输入整数a=2
请输入整数b=4

参数进来时,a=2  b=4

方法交换后,a=4  b=2

采用值参数传递交换方法后,结果应该和初值相同,Main方法中现在为a=2

经过引用参数传递交换方法后,结果应该和出方法时的值相同,Main方法中现在为b=2
请按任意键继续. . .

很明显看出,Main方法中b的值变化了,和出方法时的值相同,而a因为是传值传递,仍然是初值。参数是数值型的传址传递还有一种就是使用out关键字,那么它与ref有什么不同呢?

输出参数


输出参数传址时,要使用out关键值,out关键字允许我们以一个未初始化的变量作为参数,直接传入方法当中,在方法结束的时候,指定所要返回的值给它,而使用ref关键字传给方法之前,必须将一个数值传入到方法中,out关键字在某种程度上来说,有点像return的功能,就是把方法的结果返回到调用这个方法的主方法中,使用out关键字要注意到:主方法中传入调用的方法的out参数值应该为未初始化的,即使你初始化了,初始化的值也相当于不存在。我们来看这个例子,体会一下out的用法。

 1class Class2
 2    {
 3        //定义一个求正方形面积的方法,传入正方形的边长,返回正方形的面积
 4        static void QMJ(double bc,out  double mj)
 5          {
 6              mj = bc * bc;       
 7           }
 8
 9        //对比使用return返回面积的方法,达到的效果是一样的
10        static double returnQMJ(double bc)
11        {
12           return bc * bc;
13        }
14        static void Main()
15        {
16            Console.Write("请输入正方形的边长bc=");
17            double bc = double.Parse(Console.ReadLine());
18            Console.WriteLine();
19            //传入QMJ方法的mj是为赋初值的
20            double mj;
21
22            //通过方法调用,改变mj的值为出方法的值,打印出来,bc的值不变
23            QMJ(bc, out mj);            
24            Console.WriteLine("正方形的面积mj="+mj);
25
26            Console.WriteLine("=================");
27            //使用return方式,返回方法的结果值
28            Console.WriteLine("使用returnQMJ方法面积mj="+returnQMJ(bc));
29        }   
30    }
31

运行结果

请输入正方形的边长bc=4

正方形的面积mj=16
=================
使用returnQMJ方法面积mj=16
请按任意键继续. . .

这个例子我主要是想告诉大家使用out能够达到和return返回值一样的功能效果。

下面我们来看一下为什么加了ref和out关键字后,主方法中的数值会改变呢?这主要是因为存放参数的内存机制发生了变化而引起的。上面的3个例子都是数值类型作为参数,但是因为第二、三例子中加入了ref和out关键字,改变了数值类型按值传递的特性,改为按照传递在内存中存放的地址,按地址传递后参数的值会改变的原因就在此,因为按内存地址传递时,调用方法的参数在定义时,不会因为参数是数值类型而在线程堆栈中开辟新的空间来存放新的值,而是会在线程堆栈中存放一个指向主方法定义的变量(初值)的内存地址,当这个地址指向的内存值因为调用方法中对参数的作用(如交换,如平方)后,内存中的值就改成了调用方法作用后的值,这样在打印主方法的变量时,值自然就改成了调用方法后的值了。

接下来我们来看一个参数为引用类型的实例,因为参数本身就是引用类型(string类型除外),所以这种参数传递属于传址传递:

数组为参数的传址传递

运行结果:

数值参数传入时,数组中的每个元素值是:
1  2  3
改变后,方法内部的数组a中的每个元素值是:
2  4  6
经过方法后,Main方法中数组a的每个元素值是:
2  4  6  请按任意键继续. . .

通过这个实例,同学们应该看出引用类型作为参数时,也会影响主方法中带入到调用方法的值。下面我们来学习最后一直参数类型叫做动态传参。

动态传参


动态传参主要是指参数的个数可以根据需要改变,使用动态传参要用到parmas关键字,它的具体用法我们来看这个例子:

动态传参实例1

对照一下上个例子和本例,我们会发现,动态传参,不必规定数组的个数,而是根据需要使用,本例结果如下:

数值参数传入时,数组中的每个元素值是:
1  2  3  4
改变后,方法内部的数组a中的每个元素值是:
2  4  6  8
请按任意键继续. . .

现在我们来做下一个例子,就是调用方法中有两个参数,一个int型,一个动态的数组类型parmas int[],要告诉大家的是,如果使用parma动态参数,动态参数一定只有一个,必须当有多个参数时,动态参数的位置在最后,我们把上面的例子修改一下,大家体会一下不同。

动态传参实例2

运行结果

数值参数传入时,数组中的每个元素值是:
2  3  4  k=1

改变后,方法内部的数组a中的每个元素值是:
4  6  8  k=1

请按任意键继续. . .

可以看出因为把parmas的动态参数放到了最后,编译器就自动的把第一个值1直接给了k,把剩下的2,3,4给了数值a参数带入到方法中,所以使用parmas一定要注意到这个问题。

C# ref out parase 理解的更多相关文章

  1. object类型对象 ref参数如何理解?

    class Program { static void Main(string[] args) { Student stu = new Student { Name = "老王" ...

  2. 关于ref的一点理解

    先写一段代码 class Test { public int Count { get; set; } } static void Main(string[] args) { Test test = } ...

  3. 如何理解Java中参数传递只能传值?

    以前学习C#的时候,是完全在工作岗位上学习,一些底层较为深入的道理都不是很清楚.如今学习了Java,对于Java参数传递只能传值,不能传引用(指针)感到很困惑,在C#中不是常常说把某个引用传递到函数中 ...

  4. React Ref 其实是这样的

    大家好,我是Mokou,好久没有冒泡了,最近一直在看研究算法和数据结构方面的东西,但是似乎很多前端不喜欢看这种东西,而且目前本人算法方面也很挫,就不献丑了. 当然了,最近也开始研究React了,这篇文 ...

  5. typescript 中的 infer 关键字的理解

    infer 这个关键字,整理记录一下,避免后面忘记了.有点难以理解呢. infer infer 是在 typescript 2.8中新增的关键字. infer 可以在 extends 条件类型的字句中 ...

  6. Async Programming - 1 async-await 糖的本质(2)

    上一篇讲了这么多,其实说的就是一个事,return会被编译器重写成SetResult,所以如果我们的异步函数返回的是一个Task<int>,代码就要改成这样: using System; ...

  7. Java final修饰形参

    转自:http://java.chinaitlab.com/base/836044.html public class BB{ public int i; } public class PP{ pub ...

  8. 详解MySQL中EXPLAIN解释命令

    Explain 结果解读与实践   基于 MySQL 5.0.67 ,存储引擎 MyISAM .   注:单独一行的"%%"及"`"表示分隔内容,就象分开“第一 ...

  9. MySQL Explain 结果解读与实践

    Explain 结果解读与实践   基于 MySQL 5.0.67 ,存储引擎 MyISAM .   注:单独一行的"%%"及"`"表示分隔内容,就象分开&qu ...

随机推荐

  1. vue自定义组件(vue.use(),install)+全局组件+局部组件

    相信大家都用过element-ui.mintui.iview等诸如此类的组件库,具体用法请参考:https://www.cnblogs.com/wangtong111/p/11522520.html ...

  2. JQuery实现表格动态增加行并对新行添加事件

    实现功能: 通常在编辑表格时表格的行数是不确定的,如果一次增加太多行可能导致页面内容太多,反应变慢:通过此程序实现表格动态增加行,一直保持最下面有多个空白行. 效果: 一:原始页面 二:表1增加新行并 ...

  3. 排序算法(C++)

    冒泡排序.选择排序.快速排序.插入排序.希尔排序.归并排序.基数排序.堆排序. 推荐网址1:https://www.cnblogs.com/onepixel/articles/7674659.html ...

  4. MongoDB中的_id和ObjectId

    ObjectId是"_id"的默认类型.它设计成轻量型的,不同的机器都能用全局唯一的同种方法方便地生成它. 这是MongoDB采用ObjectId,而不是其他比较常规的做法(比如自 ...

  5. Ajax学习--理解 Ajax 及其工作原理

    Ajax 是 Asynchronous JavaScript and XML(以及 DHTML 等)的缩写. 下面是 Ajax 应用程序所用到的基本技术:• HTML 用于建立 Web 表单并确定应用 ...

  6. pom文件中的dependencyManagement和dependencies的区别

    dependencies 子项目中,自动继承父项目中的相关依赖 dependencyManagement 只是声明依赖,并不实现引入,因此子项目中需要显示的声明需要用的依赖.如果不在子项目中声明依赖, ...

  7. IFB上挂载NETEM

    转发虚拟网卡的ingress 建立虚拟网卡的ingress转发到ifb0(每一个Pod): tc qdisc add dev calixxxxxxxxxxx ingress tc filter add ...

  8. DatePicker 日期选择器

    用于选择或输入日期 选择日 以「日」为基本单位,基础的日期选择控件 基本单位由type属性指定.快捷选项需配置picker-options对象中的shortcuts,禁用日期通过 disabledDa ...

  9. C#规范整理·语言要素

    如有不理解,请留言,开始! 1. 正确操作字符串 拼接字符串一定要考虑使用 StringBuilder ,默认长度为16,实际看情况设置. StringBuilder本质: 是以非托管方式分配内存. ...

  10. Selenium 2自动化测试实战9(简单元素操作)

    一.简单元素操作 1. webdriver中常用的几个方法: clear():清除文本 send_keys(*value):模拟按键输入 click():单击元素 clear()方法用于清除文本输入框 ...