• 第9天c#可变参数,函数重载和递归


    可变参数

    概念

    定义方法时,形参列表里参数前加params关键字的参数为可变参数

    作用

    可变参数可以传入零个或多个与可变参数类型相同的参数

    注意

    1.可变参数必须是数组类型,可以是一维数组和可变数组,方法内可通过索引访问各个传入的参数

            /// <summary>
            /// 交错数组
            /// </summary>
            /// <param name="arr"></param>
            static void Test(params int[][] arr)//参数前加params关键字的参数为可变参数 params 后面跟的一定是数组的形式 ,可以是一维数组和交错数组,二维数组不行
            {                                   
                foreach (int[] item in arr)
                {
                    foreach (int tmp in item)
                    {
                        Console.Write(tmp+"	");
                    }
                    Console.WriteLine();
                }
            }
            /// <summary>
            /// 一维数组
            /// </summary>
            /// <param name="arr"></param>
            static void Test1(params int[] arr)//参数前加params关键字的参数为可变参数 params 后面跟的一定是数组的形式 ,可以是一维数组和交错数组,二维数组不行
            {
               
                for (int i = 0; i < arr.Length; i++)
                {
                    Console.Write(arr[i] + "  ");
                }
            }
    
            static void Main(string[] args)
            {
                int[] arr1 = { 1, 2 };
                int[] arr2 = { 3, 4, 5 };
                int[] arr3 = { 5, 6, 7,8 };
                Test(arr1,arr2,arr3);   //交错数组形式接收参数
    
                Test1(1, 2, 3, 4, 5);   //一维数组形式接收参数

    2.可变参数最多只能有一个

    3.只能作为参数列表中,最后一个参数(即:可变参数放最后)。

    函数重载

    如果一个类或者结构体中有两个相同的函数就会报错

    但当一个类或者结构体中存在两个或两个以上同名的函数,当这两个函数满足以下关系时,他们就构成了重载关系:

    1.参数个数不同

            static void Test()
            {
                Console.WriteLine("无参的Test");
            }
            static void Test(int num)
            {
                Console.WriteLine("一个参数的Test");
            }
            static void Test(int n1, int n2)
            {
                Console.WriteLine("2个参数的Test");
            }

    此时虽然函数名相同,但是构成了重载关系,所以不会报错

    2.参数数据类型不同(分先后次序的)

            static void Sum(params float[] num)
            {
                float sum = 0;
                for (int i = 0; i < num.Length; i++)
                {
                    sum += num[i];
                }
                Console.WriteLine("float总和是:{0}",sum);
    
            }
            static void Sum(params double[] num)
            {
                double sum = 0;
                for (int i = 0; i < num.Length; i++)
                {
                    sum += num[i];
                }
                Console.WriteLine("double总和:{0}", sum);
            }
    
            static void Sum(params int[] num)
            {
                int sum = 0;
                for (int i = 0; i < num.Length; i++)
                {
                    sum += num[i];
                }
                Console.WriteLine("int总和:{0}", sum);
            }
    
            static void Sum(params string[] num)
            {
                string sum = "";
                for (int i = 0; i < num.Length; i++)
                {
                    sum += num[i];
                }
                Console.WriteLine("string总和:{0}", sum);
            }
    
            static void Main(string[] args)
            {
    
                #region 重载
                Sum(1.2f, 3.4f, 4.2f, 4.5f);
                Sum(2.3, 4.5, 6.4, 5, 6.3);
                Sum(1, 2, 3, 4, 5);
                Sum("h", "e", "l", "l", "o");

    结果:

    函数的递归

    概念

    函数直接或间接调用函数本身,则该函数称为递归函数

            static void Main(string[] args)
            {
                //Test(0);
                //Console.WriteLine(Factorial(5));
                //Console.WriteLine(FactorialSum(10));
                Console.WriteLine(GetLength(10));
                Console.ReadKey();
            }
            static void Test(int index)
            {
                index++;
                if (index > 10)
                {
                    return;
                }
                //递归
                Test(index);
                Console.WriteLine(index);
            }
            //n!=n*(n-1)*(n-2)。。。。。。*1;
            //1.循环的条件是什么  2.结束的条件是什么
            //n*(n-1)  n=1
            static int Factorial(int n)
            {
                //结束的条件
                if (n==1)
                {
                    return 1;
                }
                return n * Factorial(n - 1);
                //          
            }
            static int FactorialSum(int num)
            {
                if (num==1)
                {
                    return 1;
                }
                //10!9!+8!+····1!
                //10!+(9个的和)
                //9!+(8个的和)
                return Factorial(num) + FactorialSum(num - 1);
            }
            //
            static float GetLength(int day)
            {
                //已知
                if (day==0)
                {
                    return 100;
                }
                return  GetLength(day - 1) * 0.5f;
    
            }
  • 相关阅读:
    个人作业十六:找水王
    个人作业十四:第一阶段个人冲刺
    个人作业十三:用户场景描述
    个人作业十二:最大子数组三
    个人作业十一:敏捷开发
    个人作业十:返回子数组二
    个人作业九:返回数组中最大子数组的和
    个人作业八:四则运算四
    个人作业七:四则运算三
    linux系统RAID
  • 原文地址:https://www.cnblogs.com/yifengs/p/14050019.html
Copyright © 2020-2023  润新知