c#语言没有强大的运算符。然而，. net框架提供了数学。战俘的方法:

返回指定数字的指定幂。

你的例子是这样的:

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);

在MSDN上有一篇关于c#团队为什么不存在指数运算符的博文。

可以加上一个幂 语言的运算符，但是 执行此操作是公平的 这在大多数程序中都很少见，而且 加上一个似乎不合理 调用Math.Pow()时的运算符是 简单。

你问:

我是否需要写一个循环或包含 另一个要处理的名称空间 指数操作吗?如果是，该怎么办 我处理指数运算用 非整数吗?

数学。Pow支持双参数，因此不需要自己编写。

我无意中看到这篇文章，希望在我的代码中使用科学符号，我使用了

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

但后来我发现你能做到

4.95E-10;

我只是想把这句话加给和我处境相似的人。

我很惊讶没有人提到这一点，但对于简单的(可能是最常见的)平方情况，您只需将其自身相乘。

float someNumber;

float result = someNumber * someNumber;

因为还没有人写过一个函数来处理两个整数，这里有一种方法:

private static long CalculatePower(int number, int powerOf)
{
    long result = number;
    for (int i = 2; i <= powerOf; i++)
        result *= number;
    return result;
}

或者在VB中。NET:

Private Function CalculatePower(ByVal number As Integer, ByVal powerOf As Integer) As Long
    Dim result As Long = number
    For i As Integer = 2 To powerOf
        result = result * number
    Next
    Return result
End Function
CalculatePower(5, 3) ' 125
CalculatePower(8, 4) ' 4096
CalculatePower(6, 2) ' 36

在寻找一种新的语言来将我们的计算软件从优秀的vb6转换到c#时，c#缺乏指数运算符对我们来说是一个很大的烦恼。

我很高兴我们用了c#，但每当我写一个包含指数的复杂方程时，它仍然让我很恼火。Math.Pow()方法使得方程式在IMO上很难读懂。

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

只要你声明至少一个变量为DoubleX，就可以很好地工作:

DoubleX a = 2;
DoubleX b = 3;

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

或者在标准double上使用显式转换器:

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

一个好的幂函数是

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

的数学。Pow功能使用了处理器的电源功能，效率更高。

无论如何，当取2的幂来定义二进制常数时，我确实忽略了^运算符。不能在这里使用Math.Pow()，但将无符号int(1)向左移动指数的值是可行的。当我需要定义一个常数(2^24)-1时:

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

记住类型必须是(uint) << (int)。

它不是运算符，但你可以写自己的扩展函数。

public static double Pow(this double value, double exponent)
{
    return Math.Pow(value, exponent);
}

这允许你写作

a.Pow(b);

而不是

Math.Pow(a, b);

我认为这使得a和b之间的关系更加清晰，而且你可以避免一遍又一遍地写“数学”。