C#——函数的参数

Biegral 2014/2/17 13:45:12 2120

函数的参数

 

（一）函数的ref、out参数

函数参数默认是值传递的，也就是“复制一份”，也就是“复制一份”，例子：

int age=20;

IncAge(age);

Console.WriteLine("age={0},age");

ref必须先初始化，因为是引用，所以必须先“有”，才能引用，而out则是内部为外部赋值，所以不需要初始化，而且外部初始化也没用。

ref应用场景内部对外部的值进行改变，out则是内部为外部变量赋值，out一般用在函数有多个返回值的场所。

例1：函数参数默认是值传递的，也就是“复制一份”，

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace refout参数  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             int age = 20;  
  8.             IncAge(age);  
  9.             Console.WriteLine(age); //20  
  10.             Console.ReadKey();  
  11.         }  
  12.         static void IncAge(int age) //复制了一份，所以IncAge内部改变的是副本。  
  13.         {  
  14.             age++;  
  15.         }  
  16.     }  
  17. }</span>  

 

例2：参数前加ref，因为是引用，外部参数必须先要初始化。

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace ref参数  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             int age = 20;               //ref是引用,外部参数必须先要初始化(赋值)  
  8.             IncAge(ref age);  
  9.             Console.WriteLine(age);     //21  
  10.             Console.ReadKey();  
  11.         }  
  12.         static void IncAge(ref int age) //ref:内部对外部参数的改变  
  13.         {  
  14.             age++;  
  15.         }  
  16.     }  
  17. }</span>  


 

例3：out:内部为外部变量赋值，内部参数要赋值，外部参数不需要初始化,而且外部初始化也没用.。

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace out参数  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //int age = 20;     //out外部参数不需要初始化,而且外部初始化也没用.  
  8.             int age;  
  9.             IncAge(out age);  
  10.             Console.WriteLine(age);        //31  
  11.             Console.ReadKey();  
  12.         }  
  13.         static void IncAge(out int age)    //out:内部为外部变量赋值  
  14.         {  
  15.             age = 30;          //out内部参数要赋值  
  16.             age++;  
  17.         }  
  18.     }  
  19. }</span>  


例4：交换两个变量的值

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace ref应用场景  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             int i1 = 10;  
  8.             int i2 = 20;  
  9.             Swap(ref i1, ref i2);  
  10.             Console.WriteLine("i1={0},i2={1}", i1, i2);  
  11.             Console.ReadKey();  
  12.         }  
  13.         //两个变量的交换  
  14.         static void Swap(ref int i1, ref int i2)  //内部的改变用ref  
  15.         {  
  16.             int temp = i1;  
  17.             i1 = i2;  
  18.             i2 = temp;  
  19.         }  
  20.     }  
  21. }  
  22. </span>  


ref应用场景：内部对外部的值进行改变ref应用场景：内部对外部的值进行改变ref应用场景：内部对外部的值进行改变ref的应用场景：内部对外部的值进行改变

例5：数字型的字符串转变为数据类型的数字

[csharp] view plaincopyprint?
  1. <span style="font-size:16px;">namespace out应用场景  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             string str = Console.ReadLine();  
  8.             int i;  
  9.             if (int.TryParse(str, out i))  //一般一个函数只能有一个返回值，若一个函数要有多个返回值，要用out  
  10.             {  
  11.                 Console.WriteLine("转换成功!{0}", i);  
  12.             }  
  13.             else  
  14.             {  
  15.                 Console.WriteLine("数据错误");  
  16.             }  
  17.             Console.ReadKey();  
  18.         }  
  19.     }  
  20. }  
  21. </span>  


一般一个函数只能有一个返回值，若一个函数要有多个返回值，要用out，这就是out的应用场景。        

 二、函数的可变参数 ——params

可变参数：参数的个数可以动态增加的，在参数前面加params关键字。

此部分的内容在我的博客：《C#——函数》中的第三部分：函数的参数有详细的说明，在此不再赘述。

 

其博客的链接： <http://blog.csdn.net/haiyan_cf/article/details/7358031>

 

最后，函数参数的总结：

 

确定函数参数的原则：自己能确定的数据自己内部解决，自己确定不了的数据通过参数传递。

C#中函数的参数前可加关键字（ref，out，params），也可以不加关键字（称为“默认参数”）。

 

函数参数默认是值传递的，也就是“复制一份”。

 

参数前加ref ，out和params 的区别:

 

区  别：

params 关键字是可变参数的标志，参数的个数可以动态增加的

out内参赋值，out一般用在函数有多个返回值的场所

ref外参赋值，内部对外部的值进行改变。

相同点：

外部和内部参数前要同时加、减 ref、out,前后要保持一致性。

 

本文转载:CSDN博客

阅读排行

分类

归档