C#（十四）之函数（方法）

C#的函数

1：声明函数

C#的函数和php的函数功能相同，但是定义方法不同

函数状态 + 返回类型 + （参数）{

       Method body：方法主体，包含了完成任务所需的指令集。

}

注意返回类型一定要与定义好的返回类型保持一致。

函数可以没有参数。

实例：

/**
* 定义一个静态函数
 */
static int hanshu(int a, int b, int c)
{
     int total = a + b + c;
     return total;
}

在主函数中调用

/* C#主要的运行函数，就是main函数 */
static void Main(string[] args)
{
     int total = hanshu(1,2,3);
     Console.WriteLine(total);  // 输出6
}

2：函数的参数

实际参数：也就是我们所说的实参。
实参是调用的时候传递的参数。
形式参数：也就是我们说的形参。
形参是函数接受的参数。

（1）：值传递：按值传递，传递给函数的值发生变化，原本的值是不会发生变化的。

/**
* 定义一个静态函数
 */
static int hanshu(int a, int b, int c)// 这里边的a,b,c是形式参数
{
     int total = a + b + c;
     return total;
}
/* C#主要的运行函数，就是main函数 */
static void Main(string[] args)
{
     int total = hanshu(1, 2, 3);// 1,2.3是实际参数
      Console.WriteLine(total);  // 输出6
}

（2）：地址传递：按值传递，传递给函数的值发生变化，原本的值会发生变化的。

复杂参数的地址传递

如果参数不是一个值，而是一个数组或者是一个对象，那么应用到地址传递。

/* C#主要的运行函数，就是main函数 */
        static void Main(string[] args)
        {
            //int total = hanshu(1, 2, 3);// 1,2.3是实际参数
            //Console.WriteLine(total);  // 输出6
            int[] number = { 1,2,3,4,5};
            foreach (var item in number)
            {
                Console.WriteLine("传递前：{0}",item);
                /*传递前：1
                传递前：2
                传递前：3
                传递前：4
                传递前：5*/
            }
  
            // 调用函数
            Message(number);
  
            foreach (var item in number)
            {
                 Console.WriteLine("传递后：{0}",item);
                /*传递后：1
                传递后：4
                传递后：9
                传递后：16
                传递后：25*/
            }
        }
  
        /**
         * 定义一个没有返回值的数组按地址传递的数组
         */
        static void Message(int[] array) {
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = array[i] * array[i];
            }
        }

引用型参数地址传递（ref）：

官方关于形参和实参以及值传递与地址传递的说法是：

按值传递的时候，实参和形参处于不同内存空间，所以，值的变化不会发生关联。

按地址传递的时候，实参和形参处于相同内存空间，所以，值得变化会发生关联。

那么如果我们想按值传递的时候达到的效果与按地址传递的效果一样，我们这里就用到了引用型参数。关键字 ： ref

ref 型参数使用前必须赋值。

/**
        * 定义一个静态函数（引用性参数）
        */
        static void Refs(ref int a, ref int b,ref int c)// 这里边的a,b,c是形式参数
        {
            a = a * a;
            b = b * b;
            c = c * c;
        }
/* C#主要的运行函数，就是main函数 */
        static void Main(string[] args)
        {
            int aa = 2;
            int bb = 3;
            int cc = 4;
            Refs(ref aa, ref bb, ref cc);
            Console.WriteLine(aa); // 4
            Console.WriteLine(bb); // 9
1.   Console.WriteLine(cc); // 16
        }

输出型参数地址传递（out）：

其用法与引用性参数大致一样，只有一个区别：

ref 关键字指定的参数必须是“变量”，且必须赋值。

Out型参数引入前不需赋值，赋值也没用。

/**
         * 定义一个静态函数（输出型参数）
         */
        static void Mess(int aa,out int bb)
        {
            int cc = aa;
            bb = aa;
            aa = 2 * cc;
        }
/* C#主要的运行函数，就是main函数 */
        static void Main(string[] args)
        {
            int aaa = 52;
            int bbb;
            Mess(aaa,out bbb);
            Console.WriteLine(aaa); //52
            Console.WriteLine(bbb); //52
            // 在函数中将aaa的值附给了输出型参数bb,实参bbb与形参bb在同一内存中，所以值得改变会关联
            // aaa 传递的参数是按值传输，所以其值得变化不受影响
        }

（3）：参数匹配

强语法类型的语言就是这样，类型不对，不好使。

在函数中，实参和形参类型不匹配，则会将形参的数据类型隐式的转换为实参的数据类型。

如果转换不了，报错。

/**
         * 定义一个静态函数
         */
        static int Sum(int a,int b)
        {
            int aa = a + b;
            return aa;
        }
        /**
         * 定义一个静态函数
         */
        static int Summ(byte a, int b)
        {
            int aa = a + b;
            return aa;
        }
static void Main(string[] args)
        {
            short one = 11;
            short two = 22;
            int res = Sum(one,two);
            Console.WriteLine(res); // 输出33
            int ult = Summ(one,two);
            Console.WriteLine(ult); // 报错：无法从“short”转换为“byte”
        }

（4）：参数数组：C#可以为函数方法指定一个特殊的参数，这个参数必须放在最后一个参数。被称为参数数组。参数数组允许使用不确定个数的数组来调用函数，使用params关键字指定。

定义函数：

public static int ArrayValue(params int[] value)
        {
            int res = 0;
            for (int i = 0; i < value.Length; i++)
            {
                res += value[i];
            }
            return res;
        }

调用：

// 参数数组
int result = ArrayValue(1,2,3,4,5);
Console.WriteLine(result);

3：递归函数

递归函数就是自己调用自己

5的阶乘：

/**
         * 定义一个递归函数
         */
        static int Digui(int a)
        {
            if (a < 1)
            {
                return 1;
            }
            else {
                return a * Digui(a - 1); //这是递归调用，自己调用自己
            }
        }
static void Main(string[] args)
        {
            int number = 5;
            int cvb = Digui(5);
            Console.WriteLine(cvb);
        }

测试使用全部代码：控制台应用程序

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace functions
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] srray = { 1,2,8,9,6,4,5,3,10,0};
            int maxData = GetMax(srray);
            Console.WriteLine(maxData);
 
            //int total = hanshu(1, 2, 3);// 1,2.3是实际参数
            //Console.WriteLine(total);  // 输出6
            /*int[] number = { 1,2,3,4,5};
            foreach (var item in number)
            {
                Console.WriteLine("传递前：{0}",item);
                /*传递前：1
                传递前：2
                传递前：3
                传递前：4
                传递前：5
            }
  
            // 调用函数
            Message(number);
  
            foreach (var item in number)
            {
                 Console.WriteLine("传递后：{0}",item);
                /*传递后：1
                传递后：4
                传递后：9
                传递后：16
                传递后：25
            }//*/
            /*int aa = 2;
            int bb = 3;
            int cc = 4;
            Refs(ref aa, ref bb, ref cc);
            Console.WriteLine(aa); // 4
            Console.WriteLine(bb); // 9
            Console.WriteLine(cc); // 16//*/
 
            /*int aaa = 52;
            int bbb;
            Mess(aaa,out bbb);
            Console.WriteLine(aaa); //52
            Console.WriteLine(bbb); //52
            // 在函数中将aaa的值附给了输出型参数bb,实参bbb与形参bb在同一内存中，所以值得改变会关联
            // aaa 传递的参数是按值传输，所以其值得变化不受影响//*/
 
            /*short one = 11;
            short two = 22;
            int res = Sum(one,two);
            Console.WriteLine(res); // 输出33
  
            int ult = Summ(one,two);
            Console.WriteLine(ult); // 报错：无法从“short”转换为“byte”//*/
 
            int number = 5;
            int cvb = Digui(5);
            Console.WriteLine(cvb);
 
            Console.WriteLine("-------------------------------------------------------");
 
            // 参数数组
            int result = ArrayValue(1,2,3,4,5);
            Console.WriteLine(result);
 
            Console.ReadKey();
        }
 
        public static int ArrayValue(params int[] value)
        {
            int res = 0;
            for (int i = 0; i < value.Length; i++)
            {
                res += value[i];
            }
            return res;
        }
 
        public static int GetMax(int[] array)
        {
            int maxValue = array[0];
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] > maxValue)
                {
                    maxValue = array[i];
                }
            }
            return maxValue;
        }
 
        /**
         * 定义一个静态函数
         */
        static int hanshu(int a, int b, int c)// 这里边的a,b,c是形式参数
        {
            int total = a + b + c;
            return total;
        }
 
        /**
         * 定义一个没有返回值的数组按地址传递的数组
         */
        static void Message(int[] array)
        {
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = array[i] * array[i];
            }
        }
 
        /**
        * 定义一个静态函数（引用性参数）
        */
        static void Refs(ref int a, ref int b, ref int c)// 这里边的a,b,c是形式参数
        {
            a = a * a;
            b = b * b;
            c = c * c;
        }
 
        /**
         * 定义一个静态函数（输出型参数）
         */
        static void Mess(int aa, out int bb)
        {
            int cc = aa;
            bb = aa;
            aa = 2 * cc;
        }
 
        /**
         * 定义一个静态函数
         */
        static int Sum(int a, int b)
        {
            int aa = a + b;
            return aa;
        }
 
        /**
         * 定义一个静态函数
         */
        static int Summ(byte a, int b)
        {
            int aa = a + b;
            return aa;
        }
 
        /**
         * 定义一个递归函数
         */
        static int Digui(int a)
        {
            if (a < 1)
            {
                return 1;
            }
            else
            {
                return a * Digui(a - 1); //这是递归调用，自己调用自己
            }
        }
 
 
    }
}

有好的建议，请在下方输入评论。

欢迎访问个人博客
https://guanchao.site

欢迎访问小程序：