C#——函数

柔光的暖阳◎ 2022-08-26 04:47 83阅读 0赞

**C\#——函数**

**一、函数的定义（如下图）**

![0_1331798266IiZu.gif][]

> **函数，参数，返回值三者的关系**（如例1）

*  **函数可能**有返回值，**可能**会有参数。
 *  **返回值**是函数的执行结果，**参数**是函数做事所需要的一些数据。

> 例1：
> 
>     [csharp] view plaincopyprint?
>     namespace 函数  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 string s = Console.ReadLine();     //返回值，执行结果  
>                 Console.WriteLine("1234");         //参数，做事所需要的一些数据  
>                 int i = Convert.ToInt32("123");    //既有参数，又有返回值  
>             }  
>         }  
>     }
> 
>   
>

**二、函数的分类**

> **（1）.net自制的函数**
> 
> >   如例1中的ReadLine()函数，WriteLine()函数，Convert.ToInt32()函数 等等
> 
> **（2）自己写的函数**

如例2，例3中的ReadInt()函数

**![0_1331799336Yq3Q.gif][]**

> **先自己写函数，然后再调用自己写的函数。**
> 
> 例2：
> 
>     [csharp] view plaincopyprint?
>     namespace 函数1  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 int i = ReadInt();  
>                 i++;  
>                 Console.WriteLine(i);  
>                 Console.ReadKey();  
>       
>             }  
>             static int ReadInt()  
>             {  
>                 //return "3"; //函数返回的数据类型必须和声明的返回值类型一样（不严谨）  
>                 return 3;  //return后跟要返回的数据  
>             }  
>         }  
>     }
> 
>   
>

> **函数一旦有返回值类型，就一定要有返回值**，返回值的类型必须和声明的返回值类型一样，return后跟返回值。
> 
> 例3：
> 
>     [csharp] view plaincopyprint?
>     namespace 函数1  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 int i = ReadInt();  
>                 i++;  
>                 Console.WriteLine(i);  
>                 Console.ReadKey();  
>             }  
>       
>             /* 
>             static int ReadInt() 
>             { 
>                 string s = Console.ReadLine(); 
>                 int i = Convert.ToInt32(s); 
>                 return i; 
>             } 
>              */  
>       
>             //另一种写法：直接返回  
>             static int ReadInt()  
>             {  
>                 string s = Console.ReadLine();  
>                 return Convert.ToInt32(s);   //直接将ToInt32的返回值返回，买空卖空！  
>             }  
>         }  
>     }
> 
>   
>

> **注意：函数的执行顺序是先进来，再回来。**  
> 
> 
> 例4：自己写的**有返回值的函数**，**无返回值的函数**
> 
>     [csharp] view plaincopyprint?
>     namespace 函数2  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                    
>             }  
>             //自己写函数  
>             static int CT(string s)  
>             {  
>                 if (s == "tom")  
>                 {  
>                     return 1;  
>                 }  
>                 if (s == "herry")  
>                 {  
>                     return 0;  
>                 }  
>                 return -1;   //一旦有返回值类型，就一定要有返回值。  
>             }  
>             static void SayHello()    //函数如果没有返回值则标记返回值类型为void.  
>             {  
>                 int i = 3;  
>                 if (i > 10)  
>                 {  
>                     return;  
>                 }  
>                 Console.WriteLine("哈喽哇！");  
>                 Console.ReadKey();  
>             }  
>         }  
>     }
> 
>   
>

>   
> **自己写函数要注意：**
> 
> > **函数一旦有返回值类型，就一定要有返回值。**
> > 
> > **函数如果没有返回值则标记返回值类型为void.**

> > return语句，导致函数立即返回。
> > 
> > 在返回值为void的函数中return,在返回值非void的函数中return数值。

**三、函数的参数**

> 函数的参数可分为**可变参数**和**非可变参数**

![0_1331801561LWeE.gif][]

**（1）非可变参数**

> 非可变参数：参数的个数是确定的（如例5，例6，例7中自己写的函数的参数个数都是确定的）。
> 
>  
> 
> **确定函数参数的原则：自己能确定的数据自己内部解决，自己确定不了的数据通过参数传递。**
> 
> **函数的参数不只一个，函数可以有两个参数（如例5）**
> 
> **函数的参数不但可以是简单的数据类型，还可以是数组（如例6）**
> 
> 例5：计算两个整数中的最大值：Int Max(int i1,int i2)
> 
>     [csharp] view plaincopyprint?
>     namespace 函数3  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 //计算两个整数中的最大值：Int Max(int i1,int i2)  
>                 Console.WriteLine(Max(30,50));  
>                 Console.ReadKey();  
>             }  
>             static int Max(int i1,int i2)   //函数可以有两个参数  
>             {  
>                 if (i1 > i2)  
>                 {  
>                     return i1;  
>                 }  
>                 return i2;  
>             }  
>         }  
>     }
> 
>   
>

> 例6：计算数组中所有元素的和
> 
> 参数可以是数组
> 
>     [csharp] view plaincopyprint?
>     namespace 函数4  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 //计算输入数组的和  
>                 int[]values={3,5,6,9};  
>                 int sum = Sum(values);  
>                 Console.WriteLine(sum);  
>                 Console.ReadKey();  
>       
>             }  
>             static int Sum(int[]values)  
>             {  
>                 int sum = 0;  
>                 foreach (int i in values)  
>                 {  
>                     sum = sum + i;  
>                 }  
>                 return sum;  
>             }  
>         }  
>     }
> 
>   
>

> **注意：函数内部的变量名和函数外部的变量名没有任何的关系。（只是看起来名字重复，其实没有任何关系。）**

> > **      **static void Main(string\[\] args)  
> >         \{  
> >             //计算输入数组的和  
> >             int\[\]values=\{3,5,6,9\};  
> >             int sum= Sum(values);  
> >             Console.WriteLine(sum);  
> >             Console.ReadKey();
> > 
> >         \}
> > 
> >   
> >         static int Sum(int\[\]values)  
> >         \{  
> >             int sum = 0;  
> >             foreach (int i in values)   
> >             \{  
> >                 sum = sum\+ i;  
> >             \}  
> >             return sum;  
> >         \}  
> > 
> 
> **如上例中的values和values，sum和sum只是看起来名字重复，其实没有任何关系。**

> 练习：有一个string数组按某个特定符号来分隔（问题描述如下）

> string\[\] strs=\{"aa","333","ccc"\};
> 
> 返回给我一个字符串，然后字符串使用我指定的分隔符进行分割，比如我指定用"|"分割，那么返回给我”aa|333|ccc“
> 
> 具体步骤：
> 
> 确定函数参数的返回值类型：stringJoin(string\[\] strs,string seperator)
> 
> 确定参数：string Join(string\[\] strs,string seperator)
> 
> 代码（如例7）
> 
>     [csharp] view plaincopyprint?
>     namespace 函数5  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 string[] names = {"tom","jerry","lucy"};  
>                 string s=Join(names,"|");  
>                 Console.WriteLine(s);  
>                 Console.ReadKey();  
>             }  
>             //定义的这个函数要把字符串数组按某个特定符号来分隔  
>             static string Join(string[] strs, string seperator)  //注意：C#中函数名字要大写字母开头  
>             {  
>                 string result = "";  
>                 for (int i = 0; i < strs.Length - 1; i++)  
>                 {  
>                     result = result + strs[strs.Length - 1];  
>                 }  
>                 if(strs.Length>0)  
>                 {  
>                     result=result+strs[strs.Length-1];  
>                 }  
>                 return result;  
>             }  
>         }  
>     }
> 
>   
>

> **c\#的命名规范：**
> 
> **C\#中函数名字、类的名字都要大写字母开头，**
> 
> **参数的名字，变量的名字都要小写字母开头，而且起的变量的名字和参数的名字要有意义。**
> 
>

**（2）可变参数**

**![0_1331809899NOYD.gif][]**

> 可变参数：参数的个数可以动态增加的，在参数前面加params关键字。
> 
> 如例7下面的Console.WriteLline()函数，它的参数就是可变参数。
> 
> 例7：
> 
>     [csharp] view plaincopyprint?
>     namespace 函数的可变参数  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 Console.WriteLine("{0}{1}{2}{3}{4}",3,4,5,8,90,7,9,50,"a","agg");  
>                 Console.ReadKey();  
>             }  
>         }  
>     }
> 
>   
>

> **可变参数也可以和非可变参数一起来用的。**
> 
> 使用可变参数据注意的问题，**可变参数必须是所有参数中的最后一个，不能把它提到前面的。**（如例8）。
> 
> 例8
> 
>     [csharp] view plaincopyprint?
>     namespace 可变参数和非可变参数  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 SayHello("tom","张大虎","狗蛋");  
>                 Console.ReadKey();  
>             }  
>       
>             //非可变参数(名字), 可变参数(呢称)一起用。注意，可变参数必须是所有参数中的最后一个  
>             static void SayHello(string name, params string[] nicknames)  
>             {  
>                 Console.WriteLine("我的名字是{0}",name);  
>                 foreach (string nickname in nicknames)  
>                 {  
>                     Console.WriteLine("我的昵称是:{0}",nickname);  
>                 }  
>             }  
>         }  
>     }
> 
>   
>

**四、函数重载（函数重名）**

![0_1331812712KmPM.gif][]

>  
> 
> **函数的默认值**：是用函数重载来实现的
> 
> **函数重载**：其实就是函数的重名
> 
> **函数的名字是可以重复，条件是函数的参数必须是不一致（不严谨）**
> 
>  
> 
> 如：例9
> 
>     [csharp] view plaincopyprint?
>     namespace 函数重载  
>     {  
>         class Program  
>         {  
>             //函数重载：就是函数的重名，但是函数的参数必须不一致。  
>             static void Main(string[] args)  
>             {  
>                 SayHello("王大壮");  
>                 SayHello("tom");  
>                 SayHello(20);  
>                 Console.ReadKey();  
>       
>             }  
>             static void SayHello(string name)  
>             {  
>                 Console.WriteLine("大家好，我是{0}",name);  
>             }  
>       
>             /*    报错：重名的函数，参数不能一样 
>             static void SayHello(string name) 
>             { 
>                 Console.WriteLine("Hello,I am {0}",name); 
>             } 
>             */  
>             static void SayHello(int age)  
>             {  
>                 Console.WriteLine("我{0}岁了",age);  
>             }  
>         }  
>     }
> 
>   
>

> **函数能否重载（能否重名），取决于参数的格式，与返回值无关。（只要函数的参数一样了，就不能重载）**

> 如例11：
> 
>     [csharp] view plaincopyprint?
>     namespace 函数重载2  
>     {  
>         class Program  
>         {  
>             static void Main(string[] args)  
>             {  
>                 //函数重载：就是函数重名，条件是函数的参数个数或者是参数的类型必须不一致。  
>                 SayHello("tom", "小懒猫");  
>                 SayHello("王大壮");  
>                 SayHello("tom");  
>                 SayHello(20);  
>                   
>                 /* 
>                 string s = SayHello("jerry"); //报错：函数是否能重载（是否能重名），取决于参数的格式，与返回值无关。 
>                  */  
>       
>                 Console.ReadKey();  
>             }  
>       
>             static void SayHello(string name)  
>             {  
>                 Console.WriteLine("大家好，我是{0}", name);  
>             }  
>       
>             static void SayHello(int age)         //参数的类型不一样，可以重载  
>             {  
>                 Console.WriteLine("我{0}岁了", age);  
>             }  
>       
>             /* 
>             //报错：函数的参数一样了，不可以重载（哪怕是你有返回值，我无返回值或者是两个返回值的类型不一致都不可以重载） 
>             static string SayHello(string name) 
>             { 
>                 return "大家好，我是:"+name;    
>             } 
>             */  
>       
>             static void SayHello(string name, string nickname)   //参数的个数不一样，可以重载  
>             {  
>                 Console.WriteLine("我的名字是{0}，我的昵称是{1}",name,nickname);  
>             }  
>         }  
>     }
> 
>   
>

> 只要函数的参数一样了，哪怕是你有返回值，我无返回值或者是两个返回值的类型不一致，都不可以重载。
> 
> **只有参数的类型不一样，参数的个数不一样，就可以构成重载。**

[0_1331798266IiZu.gif]: /images/20220824/b7bd0b6f703b466fb56c94bcf73b346b.png
[0_1331799336Yq3Q.gif]: /images/20220824/1755008ce70e4433b05cff9950c8616d.png
[0_1331801561LWeE.gif]: /images/20220824/8c49256a17214e46b8ed42a16fd5c911.png
[0_1331809899NOYD.gif]: /images/20220824/7d1b28e5cc964d538755e49a54d3538c.png
[0_1331812712KmPM.gif]: /images/20220824/2bbf78fe67d241d5a0824f388e3b3978.png