VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > 编程开发 > python入门 >
  • c#教程函数部分

1.前言
      c#教程C#不支持全局函数
      所有的函数必须在类内部声明
      无源文件和头文件之分
      所有的函数必须声明的时候被实现
int NotAllowed()      //错误,C#没有全局函数
{
            ...
}
sealed class Methods
{
    void Inline()
    { ...
    }
    void Error()
    { ...
    };                   //错误,函数不能有结尾分号
    int AlsoError();  //错误,函数必须声明的时候被实现
}
和Java一样,C#不允许有全局函数。所有的函数必须在类或结构内实现。函数是类或结构的成员,函数也被称为方法。
C#允许可以在类的声明中加入结尾分号,例如:
              sealed class Methods
              {
                            ...
              };//可以有结尾分号
但是,C#不允许在函数的声明中加入结尾分号,例如:
              sealed class Methods
              {
                            void NotAllowed() {...} ; //错误,函数不能有结尾分号
              }
2.声明函数
         函数参数列表
        各参数以逗号隔开
       参数必须命名
        没有参数时括号不能省略
sealed class Methods
{
void Error(float) //错误,参数没有命名
    { ...
    }
    void NoError(float delta)
    { ...
    }
 
 int Error(void) //错误,无参数时不允许使用void
    { ...
    }
    int NoError()
    { ...
}
}
3. 值型参数
                    一般的函数参数是实参的一个拷贝
        实参必须预先被赋值
       实参可以是常量类型
sealed class ParameterPassing
{
    static void Method(int parameter)
    {
        parameter = 42;  
    }
    static void Main()
    {
        int arg = 0;
        Console.Write(arg); //结果为0
        Method(arg);
        Console.Write(arg); //结果为0
    }
}
(注:为了叙述的方便,以后所出现的“参数”这个词均指函数参数,也就是所谓的形参)
没有被ref 或 out修饰的函数参数是一个值型参数。值型参数只有在该参数所属的函数被调用的时候才存在,并且用调用时所传递的实参的值来进行初始化。当函数调用结束时,值型参数不复存在。
只有被预先赋值的实参才能被传递给值型参数,例如:
              int arg;    // arg没有被赋初值
              Method(arg);//错误,实参必须预先赋初值
传递给函数的实参可以是纯粹的数而不是变量,例如:
              Method(42);
              Method(21 + 21);
4.c#教程引用型参数
                    引用型参数是实参的一个别名
       没有发生复制
       实参必须预先被赋值
       实参必须是一个变量类型
       实参和函数参数都要有ref
sealed class ParameterPassing
{
    static void Method(ref int parameter)
    {
        parameter = 42;
    }
    static void Main()
    {
        int arg = 0;
        Console.Write(arg); //结果为0
        Method(ref arg);
        Console.Write(arg); //结果为42
    }
}
函数参数有ref修饰符时,被称为引用型参数。引用型参数不产生新的存储区间。实际上,引用型参数是函数调用时所传递的实参所代表的变量的别名。结果是引用型参数只是实参所代表的变量的另一个名字。
ref修饰符必须同时出现在函数声明语句和函数调用语句中。
只有被预先赋值的实参才能被传递给引用型参数,例如:
              int arg;    // arg没有被赋初值
              Method(ref arg);//错误,实参必须预先赋初值
传递给引用型参数的实参必须是变量类型,而不能是纯粹的值或常量。
              Method(ref 42);  //错误,引用型参数的实参不能是纯粹的值
              const int arg = 42;
Method(ref arg); //错误,引用型参数的实参不能是常量
5.out型参数
                    out型参数是实参的一个别名
        没有发生复制
        实参不必预先赋值
        实参必须是变量类型
        函数参数必须被预先赋值才能使用
       实参和函数参数都要有out
sealed class ParameterPassing
{
    static void Method(out int parameter)
    {
        parameter = 42;
    }
    static void Main()
    {
        int arg;
        //Console.Write(arg);
        Method(out arg);
        Console.Write(arg); //结果为42
    }
}
函数参数有out修饰符时,被称为out型参数。out型参数不产生新的存储区间。实际上,out型参数是函数调用时所传递的实参所代表的变量的别名。结果是out型参数只是实参所代表的变量的另一个名字。
out修饰符必须同时出现在函数声明语句和函数调用语句中。
没有被预先赋值的实参能够被传递给引用型参数,例如:
              int arg;    // arg没有被赋初值
              Method(out arg);//正确,实参可以不赋初值
传递给out型参数的实参必须是变量类型,而不能是纯粹的值或常量。
              Method(out 42);  //错误,out型参数的实参不能是纯粹的值
              const int arg = 42;
Method(out arg); //错误,out型参数的实参不能是常量
6.in型参数?
                   readonly, const in, 都是C# 关键字
       它们不能被用于函数参数
       ref/out 型参数总是被赋于写的权力
7.函数重载
                   一个类中的函数可以有同一个名字,称为重载
       函数名和参数称为标识
       标识必须唯一
       返回值类型不是标识
namespace System
{
    public sealed class Console
    {
        public static void WriteLine()
        { ... }
        public static void WriteLine(int value)
        { ... }
        public static void WriteLine(double value)
        { ... }
        ...
        public static void WriteLine(object value)
        { ... }
        ...
    }
}
和C++与Java一样,C#允许一个类声明两个以上的同名函数,只要参数的类型或个数不同。这就是重载。但是,一个类不能包含标识为相同的实例函数和静态函数,例如:
              sealed class Illegal
              {
                            void Overload() { ... }
                            static void Overload() { ... }//错误
              }
和C++与Java一样,返回值的类型不是标识的一部分,不能被用作重载的标准,例如:
              sealed class AlsoIllegal
              {
                            int Random() { ... }
                            double Random() { ... }//错误
              }
8.ref/out重载
                    ref / out 在大部分情况下是标识的一部分!
       你可以重载一个ref型参数和一个普通参数
       你可以重载一个out型参数和一个普通参数
       你不可以重载一个ref型参数和一个out型参数
sealed class Overloading
{
    void Allowed(    int parameter)
    { ... }
    void Allowed(ref int parameter)
    { ... }
   //正确,重载一个ref型参数和一个普通参数
 
    void AlsoAllowed(    int parameter)
    { ... }
    void AlsoAllowed(out int parameter)
{ ... }
//正确,重载一个out型参数和一个普通参数
 
    void NotAllowed(ref int parameter)
    { ... }
    void NotAllowed(out int parameter)
{ ... }
//错误,不能重载一个ref型参数和一个out型参数
}
ref和out修饰符可以是一个函数的标识。但是你不能同时重载ref和out型参数。ref和out修饰符在某种意义上是“安全的“,因为只有ref型实参才能传递给ref型函数参数,只有out型实参才能传递给out型函数参数。但是,当调用函数的时候,你会非常容易忘记ref和out修饰符,所以最好不要重载ref和out型参数。例如:
              sealed class Overloading
              {
                     public static void Example(int parameter)
                     { ... }
                     public static void Example(ref int parameter)
                     { ... }
                     static void Main()
                     {
                            int argument = 42;
                            Example(argument);//在这儿非常容易忘记ref修饰符
                     }
              }
9.访问规则
         c#教程函数参数或返回值不能比所属函数的访问级别低
sealed class T { ... } //类的默认访问级别是internal
public sealed class Bad
{
    public void Parameter(T t)  //错误,函数的访问级别(public)比参数高
    { ... }
    public T Return()             //错误,函数的访问级别(public)比返回值高
    { ... }
}
public sealed class Good
{
    private void Parameter(T t)  //正确,函数的访问级别(private)比参数低
    { ... }
    private T Return()            //正确,函数的访问级别(private)比返回值低
 
    { ... }
}
10.找错误
sealed class Buggy
{
    void Defaulted(double d = 0.0)             1
    { ...
    }
    void ReadOnly(const ref Wibble w)         2
    { ...
    }
    ref int ReturnType()                        3
    { ...
    }
    ref int fieldModifier;                     4
}
第1个函数的错误是:C#中函数不能拥有缺省参数。
第2个函数的错误是:ref型参数不能用const修饰,因为ref型参数是可能变化的。
第3,4个函数的错误是:ref和out型参数只能用于函数参数和实参。
C#中可以通过函数重载的办法实现缺省参数的功能,以下是实现的方法:
              sealed class Overload
              {
                            void DefaultArgument() { DefaultArgument(0.0); }
                            void DefaultArgument(double d) { ... }
              }
 
 

相关教程