文章目录
- 函数指针=>委托
- 使用委托
- 组合委托
- 为什么在多线程环境中操作委托是线程安全的
- 调用带有返回值的委托
- 调用带引用的委托
- 总结
函数指针=>委托
typedef int (*Cal)(int, int); //定义函数指针
int Sum(int a, int b)
{
return a + b;
}
int main()
{
int a = 9, b = 2, c = 0;
c = Sum(a, b);
printf("%d\n", c);
Cal cal = ∑ //创建Sum的函数指针变量cal
c = cal(a, b);
printf("%d\n", c);
return 0;
}
//都输出11
Sum(a, b):直接调用==>CPU通过函数名直接获得函数地址并开始执行.
cal(a, b):间接调用==>通过函数指针来调用函数,CPU通过函数指针指向的值找到函数的地址并开始执行.
上面两者的实现效果一样.
那么问题来了,大家不觉得上面的函数指针实现语法*typedef int (Cal)(int, int); 太复杂了?感觉功能也比较单一,用起来太麻烦.所以就有了C#的委托出现
delegate int Cal(int a,int b);
class Program
{
static void Main(string[] args)
{
int a = 9, b = 2;
Console.WriteLine(Sum(a,b));
Cal cal = new Cal(Sum);
Console.WriteLine(cal(a,b));
}
static int Sum(int a,int b)
{ return a + b; }
}
C#中委托的声明和像函数的声明,只需要在前面加delegate关键字.
用上面的代码就可以实现C语言函数指针同样的效果.但使用起来更加方便.且委托的用处远不止于此.
使用委托
1.委托和类一样.但类是数据和方法的集合,委托只是方法集合,所以委托的声明应该放在命名空间中,与类同级别.
namespace shh
{
delegate int Cal(int a, int b);
class Calculator
{
public int Sum(int a, int b)
{ return a + b; }
public int Sub(int a, int b)
{ return a - b; }
}
class Program
{
static void Main(string[] args)
{
Calculator calculator = new Calculator();
Cal cal = new Cal(calculator.Sum);
Console.WriteLine(cal(9,2));
}
}
}
2.委托以delegate关键字开头,跟想用使用的方法有相同的参数和返回类型.(参数名不需要相同).
delegate int Cal(int a, int b);
public int Sum(int a, int b)
3.创建委托类型变量和创建委托对象不同
Cal cal ;//创建委托类型变量,没有在堆上开空间
cal = new Cal(calculator.Sum);//创建委托对象,在堆上开空间
4.创建委托对象可以使用实例方法和静态方法
namespace shh
{
delegate int Cal(int a, int b);
class Calculator
{
public int Sum(int a, int b)
{ return a + b; }
public static int Sub(int a, int b)
{ return a - b; }
}
class Program
{
static void Main(string[] args)
{
Calculator calculator = new Calculator();
Cal cal1 = new Cal(calculator.Sum);
Cal cal2 = new Cal(Calculator.Sub);
}
}
}
这里需要注意的是静态方法得用类名.方法(Calculator.Sub)
5.快捷语法
Cal cal1 = new Cal(calculator.Sum);
Cal cal2 = calculator.Su
两条语句等价,系统会自动识别并进行类型转换.
6.给委托赋值
改变委托变量的引用.赋值会创建新的委托,旧的委托会被回收
cal1 = Calculator.Sub;
创建新的委托除了为委托分配内存,还会把第一个方法(Sub)添加到委托的调用列表里面.
组合委托
namespace shh
{
delegate void Cal(int a, int b);
class Calculator
{
public void Sum(int a, int b)
{ Console.WriteLine(a+b); }
public void Sub(int a, int b)
{ Console.WriteLine(a-b); }
}
class Program
{
static void Main(string[] args)
{
Calculator calculator = new Calculator();
Cal cal1 = new Cal(calculator.Sum);
cal1 += calculator.Sub;
cal1(9, 2);
}
}
}
委托变量+=方法,会把方法添加到调用列表里面.
如果委托变量-=方法,会把方法踢出到调用列表,如果有多份(踢掉列表最后的那份)
组合委托在调用时,会执行多个方法(委托的调用列表里面的方法).
为什么在多线程环境中操作委托是线程安全的
这个运算会创建一个新的委托,旧的委托会被垃圾回收器回收.这也是为什么在多线程环境中，操作委托是线程安全的，因为每次修改都会创建一个新的对象，不会影响其他线程对旧对象的使用。
调用带有返回值的委托
namespace shh
{
delegate int Cal(int a, int b);
class Calculator
{
public int Sum(int a, int b)
{ return a + b; }
public int Sub(int a, int b)
{ return a - b; }
}
class Program
{
static void Main(string[] args)
{
Calculator calculator = new Calculator();
Cal cal1 = new Cal(calculator.Sum);
cal1 += calculator.Sub;
Console.WriteLine(cal1(9,2));
}
}
}
只会返回最后一个方法返回的值,其他值都会被忽略.
调用带引用的委托
这个也很好理解,因为我们调用委托时是按照他参数列表的顺序进行的,使用引用的值会被不断地加.
delegate int MyDel(ref int a);
class Test
{
public int Add1(ref int a)
{ return a += 5; }
public int Add2(ref int a)
{ return a += 10; }
}
class Program
{
static void Main(string[] args)
{
Test test = new Test();
MyDel mydel = test.Add1;
mydel += test.Add2;
int a = 0;
Console.WriteLine(mydel(ref a));
}
}
总结
委托其实很好理解,使用也很简单.就是一个函数指针的进化体,不要被他的名字吓住了.无非就是功能和使用体验上会优于函数指针.
