C#——函数的参数

函数的参数

 

（一）函数的ref、out参数

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

int age=20;

IncAge(age);

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

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

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

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

[csharp] view plaincopyprint?
<span style="font-size:16px;">namespace refout参数  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            int age = 20;  
            IncAge(age);  
            Console.WriteLine(age); //20  
            Console.ReadKey();  
        }  
        static void IncAge(int age) //复制了一份，所以IncAge内部改变的是副本。  
        {  
            age++;  
        }  
    }  
}</span>  

 

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

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

 

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

[csharp] view plaincopyprint?
<span style="font-size:16px;">namespace out参数  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            //int age = 20;     //out外部参数不需要初始化,而且外部初始化也没用.  
            int age;  
            IncAge(out age);  
            Console.WriteLine(age);        //31  
            Console.ReadKey();  
        }  
        static void IncAge(out int age)    //out:内部为外部变量赋值  
        {  
            age = 30;          //out内部参数要赋值  
            age++;  
        }  
    }  
}</span>  

例4：交换两个变量的值

[csharp] view plaincopyprint?
<span style="font-size:16px;">namespace ref应用场景  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            int i1 = 10;  
            int i2 = 20;  
            Swap(ref i1, ref i2);  
            Console.WriteLine("i1={0},i2={1}", i1, i2);  
            Console.ReadKey();  
        }  
        //两个变量的交换  
        static void Swap(ref int i1, ref int i2)  //内部的改变用ref  
        {  
            int temp = i1;  
            i1 = i2;  
            i2 = temp;  
        }  
    }  
}  
</span>  

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

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

[csharp] view plaincopyprint?
<span style="font-size:16px;">namespace out应用场景  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            string str = Console.ReadLine();  
            int i;  
            if (int.TryParse(str, out i))  //一般一个函数只能有一个返回值，若一个函数要有多个返回值，要用out  
            {  
                Console.WriteLine("转换成功!{0}", i);  
            }  
            else  
            {  
                Console.WriteLine("数据错误");  
            }  
            Console.ReadKey();  
        }  
    }  
}  
</span>  

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

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

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

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

 

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

 

最后，函数参数的总结：

 

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

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

 

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

 

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

 

区  别：

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

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

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

相同点：

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