实习回顾学习 c# 函数（含源码和运算符重载自定义转换）

学软件开发的猪

已于 2023-02-01 11:25:19 修改

阅读量146

点赞数

分类专栏： C# 文章标签： c# 学习开发语言

于 2023-02-01 11:20:14 首次发布

本文链接：https://blog.csdn.net/qq_71897293/article/details/128829681

版权

C# 专栏收录该内容

12 篇文章 2 订阅

订阅专栏

简写Lamba表达式

函数的简写方式 lambda 表达式 (函数中一行函数) 如果含有返回值那么 return 不用写

static double chengji(int s, int p, ref int sum) => sum = s * p;

参数数组

我们有时候想传多个同类型的数字,进方法当中。我们可以在定义方法的时候利用关键字params修饰(必须修饰的数组)。修饰之后，我们在传递参数的时候我们只需要传同类型的参数，它都将被处理为同类型的数组元素。

public static double MAX(params double[] ints)
{
IEnumerable<double> doubles = ints;
return Enumerable.Max(doubles);
}

运行效果如图

引用参数值参数(ref)

我们通常在方法当中进行。修改了值，并不会改变。传参过来的变量的值值会改变方法类定义的变量的值，意思就是。 ref。能将你传进来的变量参数改变的值重新返回给传递的参数本身

定义结构

struct KL
{
public int MAXS(int s) =>s= s * 10;
public int MAXS(ref int s) => s= s * 10;
}

示例

KL kL;
int a = 10;
kL.MAXS(a);
Console.WriteLine(a);//输出 a还是10 如果想将传递 过去的变量 最终也修改的值也影响变量本身可以用ref 定义方法;
kL.MAXS(ref a);//定义了ref 函数 传递参数时候 要加 ref 关键字
Console.WriteLine(a);
ReadKey();

输出参数（out）

Out参数你可以在传递参数的时候进行舍弃不传。但是out个人理解为多余传递出来的参数所返回的参数。 Out与上面的ref变量定义的关键字不同，ref需要。在定义的时候进行初始化赋值。 Out参数在刚开始只需要定义不需要初始化就算初始化了，在方法的运行过程中也会丢失所赋值的值。所以out参数只需要定义就行了。在方法中，改变后的值会。直接影响out的传递过来的参数变量的值。Out 必须在方法定义当中复制

定义

public int MAXX(int s, out int p)
{
p = 10000;
return s*10;
}

使用

元组

Main 函数

程序的main函数组。主函数也称。它有4种类似的方法，

其中它的参数有一个叫命令参数，可以通过自主的在右键解决方案。选择属性。选择命令行参数在命令行参数当中进行输入您需要定义的参数，其中参数之间。用空格隔开，如果定义了空格那么用分号括起来来表示空格也是参数的一部分

结构函数

结构函数呢？顾名思义，结构中包含函数之前我们所学的结构，它是中间有变量，有字段什么的，但是我们结构中也能放函数。我们通常在结构中放函数，都是进行一些简单的一些算术。计算，我们就可以加。函数，直接封装到结构里面。

函数重载

函数的重载就是我们在定义函数的时候，通常一个名字只能。有一个方法。如果你定义了2个方法为同一个名称，那么它会显示。报错。我们只需要使用函数的重载就可以实现一个方法对应。多个处理方式。具体调用哪个方法，通常都是通过您传递的参数。 Ide编译器？自主的判断。通常函数的重载通常都满足要么变量类型一致，长度不一致，变量类型长度一致。类型不一致。

委托

通过关键字。进行定义委托通常委托呢，在定义的时候就指向的函数。比如定义了一个委托指向一个方法，那它指向的方法。如果有返回值，那么函数要和他有同样的返回值以及同样数量类型一致的参数。这样就代表当前委托指向了。某个方法。定义完委托之后，当前的委托能。指向所有同返回值同参数列表的函数。如果参数列表不一致，返回值不一致的方法，当前委托是不能指向。也就是不能调用。所以委托在定义之初指向的返回值的类型以及参数列表必须与你想。调用的方法一致。

定义委托关机键 delegate

示例

delegate string actionn();//定义指向的没有参数 和返回值为 string 的函数

使用

#region 几种写法
//actionn actionns = new actionn(ReadLine);
actionn o = ReadLine;
o += ReadLine;//多播委托 多指一次方法
o = delegate { return ReadLine(); };
o = delegate () { return ReadLine(); };
#endregion

（当前简单使用方法只指向一函数和使用）

源码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static System.Console;
namespace 控制台引用
{
    public class Program
    {
        delegate string actionn();//定义指向的没有参数 和返回值为 string 的函数
        struct KL
        {
         public    int MAXS(int s) =>s= s * 10;
            public int MAXS(ref int s) => s= s * 10;
            public int MAXX(int s, out int p)
            {
                p = 10000;
                return s*10;
            }
        }
        public int old { get; set; }
        static void Main(string[] args)
        {
            //  Program program = new Program();
            //  Program program1 = new Program();
            //  program.old = 10;
            //  program1.old = 20;
            //int s=  program + program1;
            //int ss=  program - program1;
            //  Console.WriteLine(s);
            //  Console.WriteLine(ss);
            //Console.WriteLine( MAX(1));
            //Console.WriteLine(MAX(150,4545,544));
            //Console.WriteLine(MAX(100,1,1,1,11,1,57,5,7));
            KL kL;
            int a = 10;
            kL.MAXS(a);
            Console.WriteLine(a);//输出 a还是10 如果想将传递 过去的变量 最终也修改的值也影响变量本身可以用ref 定义方法;
            kL.MAXS(ref a);//定义了ref 函数 传递参数时候 要加 ref 关键字 
            Console.WriteLine(a);
            Console.WriteLine(  kL.MAXX(a, out a));   // 传递参数 out 关机键必写 且 out 不用返回 只要是赋值了变量  输出1000
                                                      // 变量在方法中的新值就会映射到变量本身 
            Console.WriteLine(kL.MAXX(a,out _));
            Console.WriteLine(a);//输出 10000

            #region 几种写法
            //actionn actionns = new actionn(ReadLine);
            actionn o = ReadLine;
            o += ReadLine;//多播委托 多指一次方法
            o = delegate { return ReadLine(); };
            o = delegate () { return ReadLine(); };
            #endregion
            ReadKey();
        }
        public static int operator +(Program program, Program program1)=> program.old + program1.old;//自定义+符号运算符重载
        public static int operator -(Program program, Program program1)=>program.old - program1.old;
        public static bool operator ==(Program program, Program program1)//自定义==号运算符重载 必须与之想对应的 ！=也要重因为他们是成对出现
        {
            if (program.old == program1.old) return true; else return false;
        }
        public static bool operator !=(Program program, Program program1)
        {
            return true;
        }
        public static implicit operator int(Program program)//implicit 自定义隐式转换
        {
            return program.old;
        }
        public static explicit operator string(Program s)//explicit 自定义强制转换
        {
            return "";
        }

        public static double MAX(params double[] ints)
        {
            IEnumerable<double> doubles = ints;
           return Enumerable.Max(doubles);
        }
        
    }
    public class OP
    {

    }
}