您的位置:新葡亰496net > 奥门新萄京娱乐场 > 函数参数,params与值类型参数修饰符

函数参数,params与值类型参数修饰符

发布时间:2019-06-16 03:48编辑:奥门新萄京娱乐场浏览(182)

    我们大概在编码中或多或少的行使过out的ref,但是是不是注意过她两的事无巨细用法以及界别?

    1.值类型:

    1.值类型:

    C# ref、out、params与值类型参数修饰符,

    1.值类型:

    图片 1

     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             NumVal(a, b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=5,b=3
     7 
     8             Console.ReadKey();
     9         }
    10 
    11 
    12         static void NumVal(int a, int b)
    13         {
    14             a = a   b;
    15             b = a - b;
    16         }
    

    代码

    值类型被用作参数时,传递的是值的别本,所以在底下的法子中修改参数的值并不可能影响函数调用中内定的参数的值。

    理当如此也可以为函数定义重回值从而获得部分想要的结果:

    图片 2

     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             int num1 = NumVal(a, b);
     6             int num2 = NumValC(a, b);
     7             Console.WriteLine("a={0},b={1}", num1, num2);     //输出结果为:a=8,b=2
     8 
     9             Console.ReadKey();
    10         }
    11 
    12         static int NumVal(int a, int b)
    13         {
    14             a = a   b;
    15             return a;
    16         }
    17 
    18         static int NumValC(int a, int b)
    19         {
    20             b = a - b;
    21             return b;
    22         }
    

    代码

    而是这么做倒霉的地点就是不能够改造当做参数的四个变量值。(因为函数唯有四个重返值)。

    2.引用类型(ref):

    图片 3

     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             NumVal(ref a, ref b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=8,b=2
     7 
     8             Console.ReadKey();
     9         }
    10 
    11         static void NumVal(ref int a, ref int b)
    12         {
    13             int c = a;      // c=5
    14             a = a   b;      // a=5 3
    15             b = c - b;      // b=5-3
    16         }
    

    代码

    此刻能够通过“引用”参数修饰符(即注重字 ref)传递参数,那样函数管理与函数调用中利用的变量就是同贰个(因为引用类型参数字传送递的是援引的地址),所以在艺术中对这一个变量进行任何改变都会潜移默化用作参数的变量的值。

    但经过 ref 修饰符修饰的变量在作为函数的参数字传送递时必须先初始化,不能够在函数中举办起头化操作。

    3.出口类型(out):

    图片 4

     1 static void Main(string[] args)
     2         {
     3             int a;
     4             int b;
     5             NumVal(out a, out b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=15,b=4
     7 
     8             Console.ReadKey();
     9         }
    10 
    11         static void NumVal(out int a, out int b)
    12         {
    13             a = 5;b = 3;        // 初始化输出参数
    14 
    15             int c = a;
    16             a = a * b;
    17             b = (c   b) / 2;
    18         }
    

    代码

    out 关键字的使用格局和 ref 关键字类似,使参数按引用传递值。

    不一样之处:ref 参数在作为参数字传送递时务必先开头化。out 参数则没有要求在传递从前伊始化(就算在传递此前已经伊始化,在函数里面也必要重新早先化,忽略传递从前起初化的值),但无法不在格局甘休再次来到以前赋值。

    4.参数数组(params):

    图片 5

     1 static void Main(string[] args)
     2         {
     3             int i = 0;
     4             int[] arr = new int[] { 1, 3, 5, 7, 9 };            //可以先定义一个数组对象
     5 
     6             SumVals(ref i, arr);                //然后把这个数组对象作为参数传递
     7 
     8             Console.WriteLine("总共有{0}个元素!", i);         //输出结果为:总共有5个元素!
     9 
    10             SumVals(ref i, 2, 4, 6, 8, 0);      //也可以直接调用
    11 
    12             Console.ReadKey();
    13         }
    14 
    15         static void SumVals(ref int i,params int[] vals)
    16         {
    17             for (i = 0; i < vals.Length; i  )
    18             {
    19                 Console.WriteLine("第{0}个元素为:{1}", i   1, vals[i]);
    20             }
    21         }
    

    代码

    C#中等高校函授数能够钦命二个特定的参数(即 params 修饰的参数数组,只可以有多个),且这么些参数必须是函数定义中的尾数参数(即 params 关键字背后不允许出现其余其它参数)。

    params 修饰的参数数组不点名参数的数据,唯一的界定正是独具的参数类型必须和参数数组是同类型。

    ref、out、params与值类型参数修饰符, 1.值项目: 1 static void Main( string [] args) 2 { 3 int a = 5 ; 4 int b = 3 ; 5 NumVal(a, b); 6 Console.WriteLine( " a={0},...

    当函数接受参数时,必须钦定下级内容

    本文想介绍下详细介绍下out参数,ref参数以及一般值参数。

    图片 6图片 7

    图片 8图片 9

    1. 函数在其定义中钦赐参数列表,以及这么些参数的门类
    2. 在各样函数调用中卓殊参数列表

    值参数

    在行使参数时,把二个值传递给函数使用的二个变量。在函数中对此变量的别的退换都不影响函数调用中钦命的参数。如下边包车型客车函数,是使函数是使传递过来的参数值加倍,并呈现出来:

     static void ShowDouble(int num)
            {
                num = num * 2;
                Console.WriteLine("num*2={0}", num);
            }
    

    参数num在函数中被加倍,假如按以下办法调用它:

                int num = 5;
                Console.WriteLine("num={0}", num);
                ShowDouble(num);
                Console.WriteLine("num={0}", num);
    

    出口到调整台的文件如下所示:

    图片 10

    把num作为参数,调用ShowDouble()并不影响Mian()中num的值,就算把num值加倍之后再赋值给num,在函数调用完之后num的值照旧不会变。

    那也没怎么难点。

    不过尽管大家想更动num的值吗?大家会想到利用为num重临新值的函数:

     static int DoubleNum(int num)
            {
                num = num * 2;
                return num;
            }
    

    函数参数,params与值类型参数修饰符。接下来调用:

                int num = 5;
                Console.WriteLine("num={0}", num);
                num = DoubleNum(num);
                Console.WriteLine("num={0}", num);
    

    这段代码不是很直观,且不可能改造当做参数的三个变量值(因为函数唯有叁个重返值)。这一年大家能够想到引用参数,即函数管理的变量和函数调用的变量同样,而不止是值同样的变量。由此对那些变量的其它更改都会潜移默化用作参数的变量值。为此,我们使用ref关键词钦命参数。

     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             NumVal(a, b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=5,b=3
     7 
     8             Console.ReadKey();
     9         }
    10 
    11 
    12         static void NumVal(int a, int b)
    13         {
    14             a = a   b;
    15             b = a - b;
    16         }
    
     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             NumVal(a, b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=5,b=3
     7 
     8             Console.ReadKey();
     9         }
    10 
    11 
    12         static void NumVal(int a, int b)
    13         {
    14             a = a   b;
    15             b = a - b;
    16         }
    
    • 参数相配:当调用函数时,必须使参数与函数定义中钦赐的参数完全相称,那代表要合营参数的体系、个数和一一
    • 参数数组

      C#允许为函数钦命三个(只可以钦定二个)特定的参数,这一个参数必须是函数定义中的最后三个参数,称为参数数组,参数数组能够应用个数不定的参数调用函数,使用params来定义。

    • 值参数

      其含义是,使用值参数时,是把多个值传递给函数使用的贰个变量,在函数中对此值的其它修改,都不影响函数调用中内定的参数,所以上面包车型客车输出i的值如故为5;
      图片 11

    • 引用参数(ref关键词):函数管理的变量和函数调用使用的变量同样,而不止是值相同的变量,由此对这一个变量的别的改变都会潜移默化用作参数的变量值输出参数

      图片 12用作ref参数的四个限制:首先不能够是常量,再者必须运用起初化过的变量

    • 输出参数(Out关键词):与ref类似但有分歧

      • 把未赋值的变量用作ref参数时违规的,但能够把未赋值的参数用作Out参数
      • 在函数中使用Out参数时,Out参数被当做是未赋值的,所以利用从前在函数内亟待对Out参数最先化,否则会报如下错误;

        图片 13

    ref参数

                int num = 5;
                Console.WriteLine("num={0}", num);
                ShowDouble(ref num);
                Console.WriteLine("num={0}", num);
    

    运作调节台结果如下:

    图片 14

    用作ref的参数的变量有八个限制:

    1.函数恐怕会转移引用参数的值,所以必须在函数调用中选拔“特别量”变量,所以上面包车型大巴代码是不被允许的:

     

                const int num = 5;
                Console.WriteLine("num={0}", num);
                ShowDouble(ref num);
                Console.WriteLine("num={0}", num);
    

    2.供给采纳开头化过的变量。C#不允许假定ref参数在函数调用时伊始化,上边包车型地铁代码也是不被允许的:

                int num;
                Console.WriteLine("num={0}", num);
                ShowDouble(ref num);
                Console.WriteLine("num={0}", num);
    

    代码

    代码

    输出参数(out)

    除开ref外,还足以钦赐out关键字,钦命所给的参数时二个输出参数,out参数和ref参数都在函数定义和函数调用中作为参数的修饰符。事实上,它的实践格局与ref参数大概完全一致,因为在函数实施完成后,该参数的值将赶回给函数调用中动用的变量。不过,二者存在一些首要分化:

    1.把未赋值的变量用作ref参数是违法的,不过未赋值的变量可以用作out参数

    2.在函数中使用out参数时,必须将其当作尚未赋值。也等于说调用代码能够把已赋值的变量用作out参数,但在函数执行时该变量的值会丢失。

    如未来有一个重临数组中最大值得马克斯()函数,获取数组中最大值得成分索引(这里要是如若有三个最大值,只回去第四个最大值索引),增多out参数:

      static int Max(int[] intArray,out int maxIndex)
            {
                int maxVal = intArray[0];
                maxIndex = 0;
                for (int i = 1; i < intArray.Length; i  )
                {
                    if(intArray[i]>maxVal)
                    {
                        maxVal = intArray[i];
                        maxIndex = i;
                    }
                }
                return maxVal;
            }
    

    调用上边的代码:

     int[] myArray = { 1, 8, 3, 6, 2, 5, 9, 3, 0, 2 };
     int maxIndex;
     Console.WriteLine("the maxium value is {0}", Max(myArray, out maxIndex));
     Console.WriteLine("the index of the maxium value is{0}", maxIndex   1);
    

    调控台出口的结果如下所示:

    图片 15

     

    值类型被作为参数时,传递的是值的别本,所以在底下的法子中期维修改参数的值并不能够影响函数调用中钦赐的参数的值。

    值类型被当做参数时,传递的是值的别本,所以在底下的措施中期维修改参数的值并无法影响函数调用中钦命的参数的值。

    自然也得认为函数定义重回值从而赢得部分想要的结果:

    当然也足感觉函数定义再次来到值从而获得一些想要的结果:

    图片 16图片 17

    图片 18图片 19

     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             int num1 = NumVal(a, b);
     6             int num2 = NumValC(a, b);
     7             Console.WriteLine("a={0},b={1}", num1, num2);     //输出结果为:a=8,b=2
     8 
     9             Console.ReadKey();
    10         }
    11 
    12         static int NumVal(int a, int b)
    13         {
    14             a = a   b;
    15             return a;
    16         }
    17 
    18         static int NumValC(int a, int b)
    19         {
    20             b = a - b;
    21             return b;
    22         }
    
     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             int num1 = NumVal(a, b);
     6             int num2 = NumValC(a, b);
     7             Console.WriteLine("a={0},b={1}", num1, num2);     //输出结果为:a=8,b=2
     8 
     9             Console.ReadKey();
    10         }
    11 
    12         static int NumVal(int a, int b)
    13         {
    14             a = a   b;
    15             return a;
    16         }
    17 
    18         static int NumValC(int a, int b)
    19         {
    20             b = a - b;
    21             return b;
    22         }
    

    代码

    代码

    不过如此做不佳的地方正是不可能改动当做参数的七个变量值。(因为函数只有贰个重返值)。

    但是如此做不佳的地方正是无法改换当做参数的七个变量值。(因为函数唯有叁个再次来到值)。

    2.引用类型(ref):

    2.引用类型(ref):

    图片 20图片 21

    图片 22图片 23

     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             NumVal(ref a, ref b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=8,b=2
     7 
     8             Console.ReadKey();
     9         }
    10 
    11         static void NumVal(ref int a, ref int b)
    12         {
    13             int c = a;      // c=5
    14             a = a   b;      // a=5 3
    15             b = c - b;      // b=5-3
    16         }
    
     1 static void Main(string[] args)
     2         {
     3             int a = 5;
     4             int b = 3;
     5             NumVal(ref a, ref b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=8,b=2
     7 
     8             Console.ReadKey();
     9         }
    10 
    11         static void NumVal(ref int a, ref int b)
    12         {
    13             int c = a;      // c=5
    14             a = a   b;      // a=5 3
    15             b = c - b;      // b=5-3
    16         }
    

    代码

    代码

    那时能够通过“引用”参数修饰符(即保养字 ref)传递参数,那样函数管理与函数调用中动用的变量正是同二个(因为引用类型参数传递的是援引的地方),所以在格局中对这几个变量举办其它修改都会潜移默化用作参数的变量的值。

    那儿能够透过“引用”参数修饰符(即入眼字 ref)传递参数,那样函数管理与函数调用中使用的变量正是同三个(因为引用类型参数传递的是援引的地点),所以在方式中对那个变量举行其余退换都会潜移默化用作参数的变量的值。

    但由此 ref 修饰符修饰的变量在作为函数的参数字传送递时必须先发轫化,无法在函数中进行开端化操作。

    但通过 ref 修饰符修饰的变量在作为函数的参数字传送递时务必先早先化,不可能在函数中开张开始化操作。

    3.输出类型(out):

    3.输出类型(out):

    图片 24图片 25

    图片 26图片 27

     1 static void Main(string[] args)
     2         {
     3             int a;
     4             int b;
     5             NumVal(out a, out b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=15,b=4
     7 
     8             Console.ReadKey();
     9         }
    10 
    11         static void NumVal(out int a, out int b)
    12         {
    13             a = 5;b = 3;        // 初始化输出参数
    14 
    15             int c = a;
    16             a = a * b;
    17             b = (c   b) / 2;
    18         }
    
     1 static void Main(string[] args)
     2         {
     3             int a;
     4             int b;
     5             NumVal(out a, out b);
     6             Console.WriteLine("a={0},b={1}", a, b);     //输出结果为:a=15,b=4
     7 
     8             Console.ReadKey();
     9         }
    10 
    11         static void NumVal(out int a, out int b)
    12         {
    13             a = 5;b = 3;        // 初始化输出参数
    14 
    15             int c = a;
    16             a = a * b;
    17             b = (c   b) / 2;
    18         }
    

    代码

    代码

    out 关键字的施用方法和 ref 关键字类似,使参数按引用传递值。

    out 关键字的使用方法和 ref 关键字类似,使参数按引用传递值。

    不一样之处:ref 参数在作为参数字传送递时务必先起始化。out 参数则不须要在传递在此以前开头化(尽管在传递以前曾经早先化,在函数里面也急需再行开端化,忽略传递此前起头化的值),但无法不在点子结束再次来到在此之前赋值。

    不一样之处:ref 参数在作为参数字传送递时必须先初叶化。out 参数则无需在传递以前开头化(即便在传递从前曾经早先化,在函数里面也急需再行初叶化,忽略传递此前开首化的值),但必须在方式甘休重回从前赋值。

    4.参数数组(params):

    4.参数数组(params):

    图片 28图片 29

    图片 30图片 31

     1 static void Main(string[] args)
     2         {
     3             int i = 0;
     4             int[] arr = new int[] { 1, 3, 5, 7, 9 };            //可以先定义一个数组对象
     5 
     6             SumVals(ref i, arr);                //然后把这个数组对象作为参数传递
     7 
     8             Console.WriteLine("总共有{0}个元素!", i);         //输出结果为:总共有5个元素!
     9 
    10             SumVals(ref i, 2, 4, 6, 8, 0);      //也可以直接调用
    11 
    12             Console.ReadKey();
    13         }
    14 
    15         static void SumVals(ref int i,params int[] vals)
    16         {
    17             for (i = 0; i < vals.Length; i  )
    18             {
    19                 Console.WriteLine("第{0}个元素为:{1}", i   1, vals[i]);
    20             }
    21         }
    
     1 static void Main(string[] args)
     2         {
     3             int i = 0;
     4             int[] arr = new int[] { 1, 3, 5, 7, 9 };            //可以先定义一个数组对象
     5 
     6             SumVals(ref i, arr);                //然后把这个数组对象作为参数传递
     7 
     8             Console.WriteLine("总共有{0}个元素!", i);         //输出结果为:总共有5个元素!
     9 
    10             SumVals(ref i, 2, 4, 6, 8, 0);      //也可以直接调用
    11 
    12             Console.ReadKey();
    13         }
    14 
    15         static void SumVals(ref int i,params int[] vals)
    16         {
    17             for (i = 0; i < vals.Length; i  )
    18             {
    19                 Console.WriteLine("第{0}个元素为:{1}", i   1, vals[i]);
    20             }
    21         }
    

    代码

    代码

    C#中等学校函授数可以钦赐二个一定的参数(即 params 修饰的参数数组,只好有一个),且那一个参数必须是函数定义中的最终一个参数(即 params 关键字背后差异意现身其余别的参数)。

    C#中等学校函授数能够钦命贰个特定的参数(即 params 修饰的参数数组,只好有多个),且那一个参数必须是函数定义中的最后叁个参数(即 params 关键字背后不相同意出现任何其余参数)。

    params 修饰的参数数组不点名参数的多少,唯一的限定就是兼具的参数类型必须和参数数组是同类型。

    params 修饰的参数数组不钦命参数的数码,唯一的范围正是富有的参数类型必须和参数数组是同类型。

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:函数参数,params与值类型参数修饰符

    关键词:

上一篇:安装和利用细节,可扩充性开采

下一篇:没有了