Question

我正在尝试编写将任意大字节数组（大于64位）转换为c＃中表示为字符串的十进制数的函数，我根本无法弄清楚如何操作。

例如以下代码......

Console.WriteLine(ConvertToString(
  new byte[]
  { 
    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 
    0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00
  }));

..应该打印出来

22774453838368691933757882222884355840

我不想仅仅使用像biginteger这样的额外库，因为我希望它很简单并且想要了解它是如何工作的。

Answer 1

一些指导原则：

您需要将数字的数字保存在矩阵中，每个数字一个空格。矩阵开始为空。
然后你需要一个矩阵来保存矩阵的乘法。它也是空的。
现在每个字节都有：
1. 首先将当前数字矩阵的每个数字乘以256，将10个模数保存在相应的临时数字中，并将数字除以10加到下一个数字乘法。
2. 将临时乘法矩阵分配给当前数字矩阵。
3. 然后将字节添加到第一个数字。
4. 更正当前矩阵，仅保存每个索引中的10个模数，并将值除以10传递给下一个索引。
然后你需要连接一个字符串中的每个数字。
返回字符串。

不要忘记根据需要扩展每个矩阵，或者根据传递的字节数确定所需的最大大小。

编辑，上面第三步的示例：

值= [0xAA，0xBB] 初始电流= [] 初始温度= []

使用0xAA

没有什么可以增加。
作业无变化。
我们将0xAA添加到当前的第一个值：Current = [170]
我们纠正当前只保存模数，将值除以10传递给下一个值：
1. 第一位：Current = [0] pass 17。
2. 第二位：当前= [0,7]传递1。
3. 第3位：当前= [0,7,1]没有要通过的值，因此流程结束。

现在有0xBB

乘以256，保存在临时和正确，为每个数字做：
1. 第一位：Temp = [0]，0保存到下一位。
2. 第二位：校正前Temp = [0,1792]，校正后Temp = [0,2]，179。
3. 第3位：校正前Temp = [0,2,1 * 256 + 179 = 435]，Temp = [0,2,5]，校正后经过43。
4. 第4位：Temp = [0,2,5,43]之前，Temp = [0,2,5,3]，3之后传递
5. 第5位：Temp =校正之前和之后的[0,2,5,3,4]，没有要保存的数字，所以乘法结束。
确定当前温度：电流= [0,2,5,3,4]; Temp = []
将当前值添加到第一个数字：Current = [187,2,5,3,4]
纠正价值观：
1. 第一位：电流= [7,2,5,3,4]，18通过。
2. 第二位：电流= [7,0,5,3,4]，2通过。
3. 第3位：当前= [7,0,7,3,4]，无法通过，因此添加结束。

现在我们只需要连接结果43707。

Answer 2

根据@ Wilheim的回答：

static string BytesToString(byte[] data) {
    // Minimum length 1.
    if (data.Length == 0) return "0";

    // length <= digits.Length.
    var digits = new byte[(data.Length * 0x00026882/* (int)(Math.Log(2, 10) * 0x80000) */ + 0xFFFF) >> 16];
    int length = 1;

    // For each byte:
    for (int j = 0; j != data.Length; ++j) {
        // digits = digits * 256 + data[j].
        int i, carry = data[j];
        for (i = 0; i < length || carry != 0; ++i) {
            int value = digits[i] * 256 + carry;
            carry = Math.DivRem(value, 10, out value);
            digits[i] = (byte)value;
        }
        // digits got longer.
        if (i > length) length = i;
    }

    // Return string.
    var result = new StringBuilder(length);
    while (0 != length) result.Append((char)('0' + digits[--length]));
    return result.ToString();
}

Answer 3

您想了解其工作方式，请查看超酷 C# BigInteger Class @ CodeProject

另外，我已经把这个课程剥夺了这个问题的基本要点。它可以进一步优化。：）

尝试复制并粘贴下面的代码！

using System;

public class BigInteger
{
    // maximum length of the BigInteger in uint (4 bytes)
    // change this to suit the required level of precision.

    private const int maxLength = 70;


    private uint[] data = null;             // stores bytes from the Big Integer
    public int dataLength;                 // number of actual chars used


    public BigInteger()
    {
        data = new uint[maxLength];
        dataLength = 1;
    }

    public BigInteger(long value)
    {
        data = new uint[maxLength];
        long tempVal = value;

        dataLength = 0;
        while (value != 0 && dataLength < maxLength)
        {
            data[dataLength] = (uint)(value & 0xFFFFFFFF);
            value >>= 32;
            dataLength++;
        }

        if (tempVal > 0)         // overflow check for +ve value
        {
            if (value != 0 || (data[maxLength - 1] & 0x80000000) != 0)
                throw (new ArithmeticException("Positive overflow in constructor."));
        }
        else if (tempVal < 0)    // underflow check for -ve value
        {
            if (value != -1 || (data[dataLength - 1] & 0x80000000) == 0)
                throw (new ArithmeticException("Negative underflow in constructor."));
        }

        if (dataLength == 0)
            dataLength = 1;
    }

    public BigInteger(ulong value)
    {
        data = new uint[maxLength];

        // copy bytes from ulong to BigInteger without any assumption of
        // the length of the ulong datatype

        dataLength = 0;
        while (value != 0 && dataLength < maxLength)
        {
            data[dataLength] = (uint)(value & 0xFFFFFFFF);
            value >>= 32;
            dataLength++;
        }

        if (value != 0 || (data[maxLength - 1] & 0x80000000) != 0)
            throw (new ArithmeticException("Positive overflow in constructor."));

        if (dataLength == 0)
            dataLength = 1;
    }

    public BigInteger(BigInteger bi)
    {
        data = new uint[maxLength];

        dataLength = bi.dataLength;

        for (int i = 0; i < dataLength; i++)
            data[i] = bi.data[i];
    }

    public BigInteger(byte[] inData)
    {
        dataLength = inData.Length >> 2;

        int leftOver = inData.Length & 0x3;
        if (leftOver != 0)         // length not multiples of 4
            dataLength++;


        if (dataLength > maxLength)
            throw (new ArithmeticException("Byte overflow in constructor."));

        data = new uint[maxLength];

        for (int i = inData.Length - 1, j = 0; i >= 3; i -= 4, j++)
        {
            data[j] = (uint)((inData[i - 3] << 24) + (inData[i - 2] << 16) +
                             (inData[i - 1] << 8) + inData[i]);
        }

        if (leftOver == 1)
            data[dataLength - 1] = (uint)inData[0];
        else if (leftOver == 2)
            data[dataLength - 1] = (uint)((inData[0] << 8) + inData[1]);
        else if (leftOver == 3)
            data[dataLength - 1] = (uint)((inData[0] << 16) + (inData[1] << 8) + inData[2]);


        while (dataLength > 1 && data[dataLength - 1] == 0)
            dataLength--;

        //Console.WriteLine("Len = " + dataLength);
    }

    public override string ToString()
    {
        return ToString(10);
    }

    public string ToString(int radix)
    {

        string charSet = "ABCDEF";
        string result = "";

        BigInteger a = this;

        BigInteger quotient = new BigInteger();
        BigInteger remainder = new BigInteger();
        BigInteger biRadix = new BigInteger(radix);

        if (a.dataLength == 1 && a.data[0] == 0)
            result = "0";
        else
        {
            while (a.dataLength > 1 || (a.dataLength == 1 && a.data[0] != 0))
            {
                singleByteDivide(a, biRadix, quotient, remainder);

                if (remainder.data[0] < 10)
                    result = remainder.data[0] + result;
                else
                    result = charSet[(int)remainder.data[0] - 10] + result;

                a = quotient;
            }
        }

        return result;
    }

    private static void singleByteDivide(BigInteger bi1, BigInteger bi2,
                                         BigInteger outQuotient, BigInteger outRemainder)
    {
        uint[] result = new uint[maxLength];
        int resultPos = 0;

        // copy dividend to reminder
        for (int i = 0; i < maxLength; i++)
            outRemainder.data[i] = bi1.data[i];
        outRemainder.dataLength = bi1.dataLength;

        while (outRemainder.dataLength > 1 && outRemainder.data[outRemainder.dataLength - 1] == 0)
            outRemainder.dataLength--;

        ulong divisor = (ulong)bi2.data[0];
        int pos = outRemainder.dataLength - 1;
        ulong dividend = (ulong)outRemainder.data[pos];

        if (dividend >= divisor)
        {
            ulong quotient = dividend / divisor;
            result[resultPos++] = (uint)quotient;

            outRemainder.data[pos] = (uint)(dividend % divisor);
        }
        pos--;

        while (pos >= 0)
        {
            dividend = ((ulong)outRemainder.data[pos + 1] << 32) + (ulong)outRemainder.data[pos];
            ulong quotient = dividend / divisor;
            result[resultPos++] = (uint)quotient;

            outRemainder.data[pos + 1] = 0;
            outRemainder.data[pos--] = (uint)(dividend % divisor);
        }

        outQuotient.dataLength = resultPos;
        int j = 0;
        for (int i = outQuotient.dataLength - 1; i >= 0; i--, j++)
            outQuotient.data[j] = result[i];
        for (; j < maxLength; j++)
            outQuotient.data[j] = 0;

        while (outQuotient.dataLength > 1 && outQuotient.data[outQuotient.dataLength - 1] == 0)
            outQuotient.dataLength--;

        if (outQuotient.dataLength == 0)
            outQuotient.dataLength = 1;

        while (outRemainder.dataLength > 1 && outRemainder.data[outRemainder.dataLength - 1] == 0)
            outRemainder.dataLength--;
    }



    public static void Main(string[] args)
    {

        BigInteger big = new BigInteger(    new byte[]
                                  { 
                                    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 
                                    0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00
                                  });

        Console.WriteLine(big);

    }

}

Answer 4

System.Decimal会满足您的需求吗？

将字节数组转换为一个十进制数字作为字符串

4 个答案: