C#——函数

Biegral 2014/2/17 13:43:45 2085

C#——函数

 

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

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

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

例1：

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

二、函数的分类

（1）.net自制的函数

  如例1中的ReadLine()函数，WriteLine()函数，Convert.ToInt32()函数 等等

（2）自己写的函数

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

先自己写函数，然后再调用自己写的函数。

例2：

[csharp] view plaincopyprint?
  1. namespace 函数1  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             int i = ReadInt();  
  8.             i++;  
  9.             Console.WriteLine(i);  
  10.             Console.ReadKey();  
  11.   
  12.         }  
  13.         static int ReadInt()  
  14.         {  
  15.             //return "3"; //函数返回的数据类型必须和声明的返回值类型一样（不严谨）  
  16.             return 3;  //return后跟要返回的数据  
  17.         }  
  18.     }  
  19. }  

函数一旦有返回值类型，就一定要有返回值，返回值的类型必须和声明的返回值类型一样，return后跟返回值。

例3：

[csharp] view plaincopyprint?
  1. namespace 函数1  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             int i = ReadInt();  
  8.             i++;  
  9.             Console.WriteLine(i);  
  10.             Console.ReadKey();  
  11.         }  
  12.   
  13.         /* 
  14.         static int ReadInt() 
  15.         { 
  16.             string s = Console.ReadLine(); 
  17.             int i = Convert.ToInt32(s); 
  18.             return i; 
  19.         } 
  20.          */  
  21.   
  22.         //另一种写法：直接返回  
  23.         static int ReadInt()  
  24.         {  
  25.             string s = Console.ReadLine();  
  26.             return Convert.ToInt32(s);   //直接将ToInt32的返回值返回，买空卖空！  
  27.         }  
  28.     }  
  29. }  

注意：函数的执行顺序是先进来，再回来。

例4：自己写的有返回值的函数，无返回值的函数

[csharp] view plaincopyprint?
  1. namespace 函数2  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.                
  8.         }  
  9.         //自己写函数  
  10.         static int CT(string s)  
  11.         {  
  12.             if (s == "tom")  
  13.             {  
  14.                 return 1;  
  15.             }  
  16.             if (s == "herry")  
  17.             {  
  18.                 return 0;  
  19.             }  
  20.             return -1;   //一旦有返回值类型，就一定要有返回值。  
  21.         }  
  22.         static void SayHello()    //函数如果没有返回值则标记返回值类型为void.  
  23.         {  
  24.             int i = 3;  
  25.             if (i > 10)  
  26.             {  
  27.                 return;  
  28.             }  
  29.             Console.WriteLine("哈喽哇！");  
  30.             Console.ReadKey();  
  31.         }  
  32.     }  
  33. }  


自己写函数要注意：

函数一旦有返回值类型，就一定要有返回值。

函数如果没有返回值则标记返回值类型为void.

return语句，导致函数立即返回。

在返回值为void的函数中return,在返回值非void的函数中return数值。

三、函数的参数

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

（1）非可变参数

非可变参数：参数的个数是确定的（如例5，例6，例7中自己写的函数的参数个数都是确定的）。

 

确定函数参数的原则：自己能确定的数据自己内部解决，自己确定不了的数据通过参数传递。

函数的参数不只一个，函数可以有两个参数（如例5）

函数的参数不但可以是简单的数据类型，还可以是数组（如例6）

例5：计算两个整数中的最大值：Int Max(int i1,int i2)

[csharp] view plaincopyprint?
  1. namespace 函数3  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //计算两个整数中的最大值：Int Max(int i1,int i2)  
  8.             Console.WriteLine(Max(30,50));  
  9.             Console.ReadKey();  
  10.         }  
  11.         static int Max(int i1,int i2)   //函数可以有两个参数  
  12.         {  
  13.             if (i1 > i2)  
  14.             {  
  15.                 return i1;  
  16.             }  
  17.             return i2;  
  18.         }  
  19.     }  
  20. }  

例6：计算数组中所有元素的和

参数可以是数组

[csharp] view plaincopyprint?
  1. namespace 函数4  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //计算输入数组的和  
  8.             int[]values={3,5,6,9};  
  9.             int sum = Sum(values);  
  10.             Console.WriteLine(sum);  
  11.             Console.ReadKey();  
  12.   
  13.         }  
  14.         static int Sum(int[]values)  
  15.         {  
  16.             int sum = 0;  
  17.             foreach (int i in values)  
  18.             {  
  19.                 sum = sum + i;  
  20.             }  
  21.             return sum;  
  22.         }  
  23.     }  
  24. }  

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

      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?
  1. namespace 函数5  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             string[] names = {"tom","jerry","lucy"};  
  8.             string s=Join(names,"|");  
  9.             Console.WriteLine(s);  
  10.             Console.ReadKey();  
  11.         }  
  12.         //定义的这个函数要把字符串数组按某个特定符号来分隔  
  13.         static string Join(string[] strs, string seperator)  //注意：C#中函数名字要大写字母开头  
  14.         {  
  15.             string result = "";  
  16.             for (int i = 0; i < strs.Length - 1; i++)  
  17.             {  
  18.                 result = result + strs[strs.Length - 1];  
  19.             }  
  20.             if(strs.Length>0)  
  21.             {  
  22.                 result=result+strs[strs.Length-1];  
  23.             }  
  24.             return result;  
  25.         }  
  26.     }  
  27. }  

c#的命名规范：

C#中函数名字、类的名字都要大写字母开头，

参数的名字，变量的名字都要小写字母开头，而且起的变量的名字和参数的名字要有意义。

 

（2）可变参数

 

可变参数：参数的个数可以动态增加的，在参数前面加params关键字。

如例7下面的Console.WriteLline()函数，它的参数就是可变参数。

例7：

[csharp] view plaincopyprint?
  1. namespace 函数的可变参数  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             Console.WriteLine("{0}{1}{2}{3}{4}",3,4,5,8,90,7,9,50,"a","agg");  
  8.             Console.ReadKey();  
  9.         }  
  10.     }  
  11. }  

 

可变参数也可以和非可变参数一起来用的。

使用可变参数据注意的问题，可变参数必须是所有参数中的最后一个，不能把它提到前面的。（如例8）。

例8

[csharp] view plaincopyprint?
  1. namespace 可变参数和非可变参数  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             SayHello("tom","张大虎","狗蛋");  
  8.             Console.ReadKey();  
  9.         }  
  10.   
  11.         //非可变参数(名字), 可变参数(呢称)一起用。注意，可变参数必须是所有参数中的最后一个  
  12.         static void SayHello(string name, params string[] nicknames)  
  13.         {  
  14.             Console.WriteLine("我的名字是{0}",name);  
  15.             foreach (string nickname in nicknames)  
  16.             {  
  17.                 Console.WriteLine("我的昵称是:{0}",nickname);  
  18.             }  
  19.         }  
  20.     }  
  21. }  

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

 

 

函数的默认值：是用函数重载来实现的

函数重载：其实就是函数的重名

函数的名字是可以重复，条件是函数的参数必须是不一致（不严谨）

 

如：例9

[csharp] view plaincopyprint?
  1. namespace 函数重载  
  2. {  
  3.     class Program  
  4.     {  
  5.         //函数重载：就是函数的重名，但是函数的参数必须不一致。  
  6.         static void Main(string[] args)  
  7.         {  
  8.             SayHello("王大壮");  
  9.             SayHello("tom");  
  10.             SayHello(20);  
  11.             Console.ReadKey();  
  12.   
  13.         }  
  14.         static void SayHello(string name)  
  15.         {  
  16.             Console.WriteLine("大家好，我是{0}",name);  
  17.         }  
  18.   
  19.         /*    报错：重名的函数，参数不能一样 
  20.         static void SayHello(string name) 
  21.         { 
  22.             Console.WriteLine("Hello,I am {0}",name); 
  23.         } 
  24.         */  
  25.         static void SayHello(int age)  
  26.         {  
  27.             Console.WriteLine("我{0}岁了",age);  
  28.         }  
  29.     }  
  30. }  

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

如例11：

[csharp] view plaincopyprint?
  1. namespace 函数重载2  
  2. {  
  3.     class Program  
  4.     {  
  5.         static void Main(string[] args)  
  6.         {  
  7.             //函数重载：就是函数重名，条件是函数的参数个数或者是参数的类型必须不一致。  
  8.             SayHello("tom", "小懒猫");  
  9.             SayHello("王大壮");  
  10.             SayHello("tom");  
  11.             SayHello(20);  
  12.               
  13.             /* 
  14.             string s = SayHello("jerry"); //报错：函数是否能重载（是否能重名），取决于参数的格式，与返回值无关。 
  15.              */  
  16.   
  17.             Console.ReadKey();  
  18.         }  
  19.   
  20.         static void SayHello(string name)  
  21.         {  
  22.             Console.WriteLine("大家好，我是{0}", name);  
  23.         }  
  24.   
  25.         static void SayHello(int age)         //参数的类型不一样，可以重载  
  26.         {  
  27.             Console.WriteLine("我{0}岁了", age);  
  28.         }  
  29.   
  30.         /* 
  31.         //报错：函数的参数一样了，不可以重载（哪怕是你有返回值，我无返回值或者是两个返回值的类型不一致都不可以重载） 
  32.         static string SayHello(string name) 
  33.         { 
  34.             return "大家好，我是:"+name;    
  35.         } 
  36.         */  
  37.   
  38.         static void SayHello(string name, string nickname)   //参数的个数不一样，可以重载  
  39.         {  
  40.             Console.WriteLine("我的名字是{0}，我的昵称是{1}",name,nickname);  
  41.         }  
  42.     }  
  43. }  


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

只有参数的类型不一样，参数的个数不一样，就可以构成重载。      

本文转载:CSDN博客

阅读排行

分类

归档