如何使乘法运算符(*)表现为短路

本文关键字：短路 何使乘 运算符 | 更新日期: 2023-09-27 18:12:11

我有很多计算，特别是乘法，其中第一部分有时是零，在这种情况下我不想计算第二个操作数。c#中至少有两个短路运算符:&&和||，它们只在必要时计算第二个操作数。我想用乘法运算符实现类似的行为。

在.net中不能直接重载&&操作符，但可以重载&和false操作符，因此可以使用扩展点来改变短路操作符的行为。你可以在这篇文章中找到更多的细节c#操作符重载:' && '操作符

是否有任何方法来实现这个或类似的乘法运算符的行为?

这是一个纯粹的语法问题，因为实现非常简单。下一个方法实现了我想要的功能:

public static double ShortCircuitMultiply(double val, Func<double> anotherValue)
{
    var epsilon = 0.00000001;
    return Math.Abs(val) < epsilon ? 0 : val * anotherValue();
}

注意:这个实现是不完整的:在 c# 如果你乘以0.0与Double.NaN或Double.NegativeInfinity或Double.PositiveInfinity，你会得到NaN，但在ShortCircuitMultiply方面-只有零。让我们忽略这个细节，它与我的领域无关。

所以现在如果我把它叫做ShortCircuitMultiply(0.0, longOperation)，其中longOperation是Func<double>，最后一项不会被计算，操作的结果将有效地为零。

问题是，正如我已经说过的，我会有很多ShortCircuitMultiply调用，我想让代码更可读。如果可能的话，我希望代码类似于0.0 * longOperation()。

另一个注意事项:我试图在double上构建包装器，并创建隐式强制转换，以double和重载*操作符。我明白，这可能是多余的:我想要实现可读性，但又试图构建另一个包装器。无论如何，下一段代码演示了我的意图:

class MyDouble
{
    double value;
    public MyDouble(double value)
    {
        this.value = value; 
    }
    public static MyDouble operator *(MyDouble left, MyDouble right) 
    {
        Console.WriteLine ("* operator call");
        return new MyDouble(left.value * right.value);
    }
    public static implicit operator double(MyDouble myDouble)
    {
        Console.WriteLine ("cast to double");
        return myDouble.value;
    }
    public static implicit operator MyDouble(double value)
    {
        Console.WriteLine ("cast to MyDouble");
        return new MyDouble(value);
    }
}

现在如果我输入:

MyDouble zero = 0;
Console.WriteLine (zero * longOperation()); //longOperation is still Func<double>

我收到:

cast to MyDouble            
called longOperation        <-- want to avoid this (it's printed from longOperation body)
cast to double             
cast to MyDouble
* operator call
cast to double   
0

但是正如您所看到的，longOperation在调用重载操作符之前很久就被求值了，并且我不能用Func或Expression替换其中一个参数以使其懒惰。

如何使乘法运算符(*)表现为短路

没有办法轻松地做你想做的事。c#语言是一种非常"急切"的语言，因为它总是在运行操作符之前求值操作数，即使正如您注意到的那样，您可以通过了解其中一个而跳过另一个。唯一的例外是? :及其等价的&&、||和??。(所有这些都可以简化为? : .)

正如您正确注意到的，您可以通过使用lambda实现惰性;Func<T>表示T，它将按需计算。但是正如您正确注意到的那样，这样做的语法相当重量级。

考虑用Haskell写程序，如果你必须使用惰性算术。它非常懒惰，而且我认为定义自己的操作符语义非常容易。f#也是一种选择，对于c#程序员来说可能更容易学习。

您的MyDouble包装器类的问题是您通过直接调用longOperation来使用它。因为*没有短路，所以直接调用

相反，您可以让包装器接受Func<double>作为第二个参数，而不是双精度值本身。所以它会像ShortCircuitMultiply函数一样工作:

public static MyDouble operator *(MyDouble left, Func<double> right)
{
    return Math.Abs(left.value) < epsilon ? new MyDouble(0) : new MyDouble(left.value * right());
}

那么你可以这样使用:

MyDouble x = 0;
Console.WriteLine(x * LongOperation);

even chain works 

MyDouble x = 5;
Console.WriteLine(x * OperationReturingZero * LongOperation);

完整的示例

class Program
{
    static void Main()
    {
        MyDouble x = 0;
        Console.WriteLine(x * LongOperation);
        MyDouble y = 5;
        Console.WriteLine(y * OperationReturningZero * LongOperation);
        Console.ReadLine();
    }
    private static double LongOperation()
    {
        Console.WriteLine("LongOperation");
        return 5;
    }
    private static double OperationReturningZero()
    {
        Console.WriteLine("OperationReturningZero");
        return 0;
    }
}
class MyDouble
{
    private static double epsilon = 0.00000001;
    private double value;
    public MyDouble(double value)
    {
        this.value = value;
    }
    public static MyDouble operator *(MyDouble left, Func<double> right)
    {
        Console.WriteLine("* (MyDouble, Func<double>)");
        return Math.Abs(left.value) < epsilon ? new MyDouble(0) : new MyDouble(left.value * right());
    }
    public static MyDouble operator *(MyDouble left, MyDouble right)
    {
        Console.WriteLine("* (MyDouble, MyDouble)");
        return new MyDouble(left.value * right.value);
    }
    public static implicit operator double(MyDouble myDouble)
    {
        Console.WriteLine("cast to double");
        return myDouble.value;
    }
    public static implicit operator MyDouble(double value)
    {
        Console.WriteLine("cast to MyDouble");
        return new MyDouble(value);
    }
}
输出:

cast to MyDouble
* (MyDouble, Func<double>)
cast to double
0
cast to MyDouble
* (MyDouble, Func<double>)
OperationReturningZero
* (MyDouble, Func<double>)
cast to double
0

你可以为double写一个扩展方法，但我不确定这是否真的是你想要的。

你可以写这样的代码:

double z = someNumberThatMightBeZero();
double r = z.Times(number);

其中number是返回double类型的方法。

using System;
namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            double z = zero();
            double r = z.Times(number);
            Console.WriteLine(r);
        }
        static double zero()
        {
            return 0;
        }
        static double number()
        {
            Console.WriteLine("in number()");
            return 100;
        }
    }
    public static class DoubleExt
    {
        public static double Times(this double val, Func<double> anotherValue)
        {
            const double epsilon = 0.00000001;
            return Math.Abs(val) < epsilon ? 0 : val * anotherValue();
        }
    }
}

我能看到的最接近的东西是这样的:

  struct LazyDouble {
    Func<double> Func;
    public LazyDouble(Func<double> func) : this() { Func = func; }
    public static implicit operator LazyDouble (double value) { 
      return new LazyDouble(()=>value); 
    }
    public static LazyDouble operator * (LazyDouble lhs, LazyDouble rhs) {
      var lhsValue = lhs.Func();
      if ( lhsValue == 0)
        return 0;
      else 
        return new LazyDouble(() => lhsValue * rhs.Func());
    }
    // other operators as necessary
  }
相关文章：