c#中函数的形参

ゝ一纸荒年。 2022-07-15 12:09 214阅读 0赞

c\#中函数的形参分为4种类型：

1 值类型

2 引用类型

3 数组类型 ：不定长参数问题的解决方案

4 out类型：多个返回值问题的解决方案

值类型的参数在调用的函数中新开辟了一个参数的内存空间

C\#的值类型包括：结构体（数值类型，bool型，用户定义的结构体），枚举，可空类型。

public  class  Compute
    {
           public void Add(int i)
           {
                 i++;
           }
    }
    class Program
    {
            static void Main(string[] args)
            {
                 int i = 0;
    
                 Compute objCompute = new Compute();
    
                 objCompute.Add(i);
    
                 Console.WriteLine(i);
            }
    }
    output：0

引用类型：引用型参数和值参数不同，引用型参数并不会开辟新的内存区域。传递的是内存地址的一份拷贝，因此都是操作相同的数据空间。

C\#的引用类型包括：数组，用户定义的类、接口、委托，object，字符串

引用型参数一般是在以下两种情况下存在1)方法的形参本身就是引用类型  
2)通过声明ref关键字的参数是按引用传递

public  class  Compute
    {
           public void Add(ref int i)
           {
                 i++;
           }
    }
    class Program
    {	
    	//本类演示引用类型的参数
            static void Main(string[] args)
            {
                 int i = 0;
    
                 Compute objCompute = new Compute();
    
                 objCompute.Add(ref i);
    
                 Console.WriteLine(i);
            }
    }
    
    output：1

return i,j；非法的，只能返回一个结果  
out类型，输出类型的出现是高一级的return，它解决了返回多个参数的问题。

public class Compute
            {
                public void Add(out int i,out int j)//与引用类型的参数类似，输出类型的参数也不会开辟新的内存空间，即在调用的函数中操作参数本身。
                {
                    i = 0;
                    i++;
                    j = 0;
                    j++;
                }
    
    
            }
    
    
            class Program
            {
                static void Main(string[] args)
                {
                    int i;
                    int j; // 注意out类型的参数不需要初始化即可使用
                    Compute objCompute = new Compute();
    
    
                    objCompute.Add(out i,out j); // 注意out类型的参数不需要初始化即可使用
    
    
                    Console.WriteLine("i={0},j={1}",i,j);
                   
                }
            }
    output：i=1,j=1

数组类型的参数：原来我现在才发现，我一直把数组类型潜意识默认为基本类型的数据组。并不是这样的！数组可以存储任何类型的数据！诸看官有则改之，无则加冕

数组类型的参数实际上是解决了不定长参数的问题。

public class Compute
        {
            public void Add(params int[] arr)
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    arr[i]++;
                   
                }
            }
            public void AddToo(params int[] arr)
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    arr[i]++;
                    Console.WriteLine(arr[i]);
                }
            }
        }
    
    
        class MultiParam
        {
            //本类演示不定长参数的解决方案。不要把目光局限于基本类型的数据。
            static void Main(string[] args)
            {
               
                Compute objCompute = new Compute();
    
                //方法一：把不定长参数封装在一个数组中，传递数组的索引
                int[] arr = { 1, 2, 3 };
                objCompute.Add(arr);
                for (int i = 0; i < arr.Length; i++)
                {
                    Console.WriteLine(arr[i]);
                }
    
                //方法二： 直接传递不定长参数
                objCompute.AddToo(1, 2, 3, 4);
    
    
            }
        }
    output: 
    2
    3
    4
    2
    3
    4
    5