C＃中有指数运算符吗？

Question

例如，是否存在一个操作符来处理这个问题？

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Number1 (operator) Number2; 

在过去的^运营商一直担任在其他语言中的指数操作，但在C＃这是一个逐位运算符。

我是否必须编写循环或包含其他名称空间来处理指数运算？如果是这样，我该如何处理使用非整数的指数运算？

Answer 1

C＃语言doesn't have a power operator。但是，.NET Framework提供了Math.Pow方法：

返回指定的数字，并将其提升到指定的功率。

所以，你的例子是这样的：

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Math.Pow(Number1, Number2); 

Answer 2

有从C＃团队blog post on MSDN about why an exponent operator does NOT exists。

这将有可能到电源 运营商加入到语言，但 执行此操作是一个相当 罕见的事情在大多数程序做的， 它似乎并没有理由的添加 操作当致电Math.Pow（）时为 简单。

---

你问：

我必须写一个循环或包括 另一个命名空间来处理 指数运算？如果是这样， 我如何处理使用 非整数的指数操作？

Math.Pow支持双参数，因此不需要您编写自己的参数。

Answer 3

我无意中发现这个帖子看在我的代码用科学记数法，我用

4.95*Math.Pow(10,-10); 

但后来我发现，你可以做

4.95E-10; 

只是想我想补充一点的人在类似的情况下，我在。

Answer 4

我很惊讶没有人提到过这一点，但对于简单的（也许是最常遇到的）平方的情况下，你只是乘以其小精灵。

float Result, Number1; 

Result = Number1 * Number1; 

Answer 5

因为没有人尚未写了一个函数来做到这一点有两个整数，这里有一个方法：

private long CalculatePower(int Number, int PowerOf) { 
    long Result = Number;  
    for (int i = PowerOf; i > 1; i--) { 
     Result = (Result * Number); 
    } 
    return Result; 
} 
CalculatePower(5, 3); // 125 
CalculatePower(8, 4); // 4096 
CalculatePower(6, 2); // 36 

或者在VB。NET：

Private Function CalculatePower(Number As Integer, PowerOf As Integer) As Long 
    Dim Result As Long = Number 
    For i As Integer = PowerOf To 2 Step -1 
     Result = (Result * Number) 
    Next 
    Return Result 
End Function 
CalculatePower(5, 3) ' 125 
CalculatePower(8, 4) ' 4096 
CalculatePower(6, 2) ' 36 

Answer 6

缺少了C＃的指数运营商是一个很大的烦恼为我们寻找一种新的语言给我们的计算软件转换成从善醇” VB6的时候。

我很高兴我们用C＃去了，但是当我写一个包括指数的复杂方程时，它仍然让我很烦恼。 Math.Pow（）方法使得方程很难读取IMO。

我们的解决方案是创建一个特殊的DoubleX类，其中我们覆盖了^ - 运算符（见下文）

这只要你声明变量DoubleX的至少一个运作得相当好：

DoubleX a = 2; 
DoubleX b = 3; 

Console.WriteLine($"a = {a}, b = {b}, a^b = {a^b}"); 

或使用标准的双打明确的转换器：使用此方法是，虽然指数在错误的顺序COMPA计算

double c = 2; 
double d = 3; 

Console.WriteLine($"c = {c}, d = {d}, c^d = {c^(DoubleX)d}");  // Need explicit converter 

的一个问题红色给其他运营商。

DoubleX a = 2; 
DoubleX b = 3; 

Console.WriteLine($"a = {a}, b = {b}, 3+a^b = {3 + a^b}");  // Wrong result 
Console.WriteLine($"a = {a}, b = {b}, 3+a^b = {3 + (a^b)}");  // Correct result 

我希望这可以帮助别人谁使用了大量复杂的公式中：这可以通过始终把额外的（）在其周围又使得它有点难以阅读的公式操作来避免他们的代码，也许有人甚至有如何改进这种方法的想法？！ :-)

DoubleX类：

using System; 

namespace ExponentialOperator 
{ 
    /// <summary> 
    /// Double class that uses^as exponential operator 
    /// </summary> 
    public class DoubleX 
    { 
     #region ---------------- Fields ---------------- 

     private readonly double _value; 

     #endregion ------------- Fields ---------------- 

     #region -------------- Properties -------------- 

     public double Value 
     { 
      get { return _value; } 
     } 

     #endregion ----------- Properties -------------- 

     #region ------------- Constructors ------------- 

     public DoubleX(double value) 
     { 
      _value = value; 
     } 

     public DoubleX(int value) 
     { 
      _value = Convert.ToDouble(value); 
     } 

     #endregion ---------- Constructors ------------- 

     #region --------------- Methods ---------------- 

     public override string ToString() 
     { 
      return _value.ToString(); 
     } 

     #endregion ------------ Methods ---------------- 

     #region -------------- Operators --------------- 

     // Change the^operator to be used for exponents. 

     public static DoubleX operator ^(DoubleX value, DoubleX exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     public static DoubleX operator ^(DoubleX value, double exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     public static DoubleX operator ^(double value, DoubleX exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     public static DoubleX operator ^(DoubleX value, int exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     #endregion ----------- Operators --------------- 

     #region -------------- Converters -------------- 

     // Allow implicit convertion 

     public static implicit operator DoubleX(double value) 
     { 
      return new DoubleX(value); 
     } 

     public static implicit operator DoubleX(int value) 
     { 
      return new DoubleX(value); 
     } 

     public static implicit operator Double(DoubleX value) 
     { 
      return value._value; 
     } 

     #endregion ----------- Converters -------------- 
    } 
}