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

我偶然发现这篇帖子在我的代码中使用科学记数法，我用了

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

但后来我发现你可以做到

4.95E-10;

我想我会为处于类似情况的人添加此内容。

Answer 3

来自C＃团队的blog post on MSDN about why an exponent operator does NOT exists。

可以增加力量运营商的语言，但执行此操作是公平的在大多数程序中都很少见，而且添加一个似乎没有道理调用Math.Pow（）时的运算符是简单。

你问：

我是否必须编写循环或包含要处理的另一个命名空指数运算？如果是这样，怎么做我使用指数操作非整数？

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

Answer 4

C＃的指数运算符的缺乏对我们来说是一个很大的烦恼，因为我们正在寻找一种新的语言来将我们的计算软件转换为好的语言。 VB6。

我很高兴我们选择了C＃，但每当我写一个包含指数的复杂方程时，它仍然会让我感到懊恼。 Math.Pow（）方法使方程很难读取IMO。

我们的解决方案是创建一个特殊的DoubleX类，我们覆盖^ -operator（见下文）

只要您将至少一个变量声明为DoubleX：

，这种方法就可以正常工作

DoubleX a = 2;
DoubleX b = 3;

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

或在标准双打上使用显式转换器：

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 --------------
    }
}

Answer 5

我很惊讶没有人提到这一点，但对于简单（也可能是最常遇到）的平方情况，你只需要自己繁殖。

float Result, Number1;

Result = Number1 * Number1;

Answer 6

由于没有人用两个整数编写了一个函数来执行此操作，所以这是一种方式：

export class Component implements OnInit {

  destinations = [];

  constructor(public myService: MyService) {
  }

  ngOnInit() {
    this.myService.getDestinations()
        .subscribe(data => {
          destinations = data
       });
  }

}

或者在VB.NET中：

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

Answer 7

好的幂函数应该是

    public long Power(int number, int power) {
        if (number == 0) return 0;
        long t = number;
        int e = power;
        int result = 1;
        for(i=0; i<sizeof(int); i++) {
            if (e & 1 == 1) result *= t;
            e >>= 1;
            if (e==0) break;
            t = t * t;
        }
    }

“ Math.Pow”功能使用处理器电源功能，效率更高。

Answer 8

对于什么值，当提高2的幂来定义二进制常量时，我确实想念^运算符。不能在此处使用Math.Pow（），但可以将指数值向左移动无符号整数1到位。当我需要定义（2 ^ 24）-1的常量时：

public static int Phase_count = 24;
public static uint PatternDecimal_Max = ((uint)1 << Phase_count) - 1;

记住类型必须是（uint）<<（int）。

C＃中是否有指数运算符？

8 个答案: