Программа высокой точности, которая вычисляет 2 ^ n

Вот моя быстрая и грязная реализация подхода Хаммара., где десятичное число хранится в виде строки C с цифрами в обратном порядке .

Запустите код на ideone

void doubleDecimal(char * decimal)
{
    char buffer[256] = "";
    char c;
    unsigned char d, carry = 0;
    int i = 0;

    while (c = decimal[i])
    {
        d = 2 * (c - '0') + carry;
        buffer[i] = (d % 10) + '0';
        carry = d / 10;
        i++;
    }

    if (carry > 0)
        buffer[i++] = (carry % 10) + '0';

    buffer[i] = '\0';
    strncpy(decimal, buffer, 256);
}

void reverse(char * str)
{
    int i = 0;
    int j = strlen(str) - 1;

    while (j > i)
    {
        char tmp = str[i];
        str[i] = str[j];
        str[j] = tmp;

        i++;
        j--;
    }
}

int main(void)
{
    char decimal[256] = "1";
    int i;

    for (i = 0; i < 100; i++)
        doubleDecimal(decimal);

    reverse(decimal);
    printf("%s", decimal);

    return 0;
}

Вывод:

1267650600228229401496703205376

Я думаю, что будет проще, если вы с самого начала будете работать с базой 10. Это связано с тем, что, хотя вычисление степени двойки в двоичном формате тривиально, преобразование обратно в основание 10 намного сложнее.

Если у вас есть массив из 10 цифр ¹, вам нужно только реализовать сложение по основанию 10 с переносом, чтобы иметь возможность умножать на 2 (путем добавления числа к самому себе). Сделайте это n раз в цикле, и вы получите ответ.

Если вы хотите поддерживать более высокие показатели, вы также можете рассмотреть возможность возведения в степень возведением в квадрат, но это сложнее, поскольку вам понадобится общее умножение, а не только для этого 2.

_{¹ Совет: удобнее хранить цифры в обратном порядке.}

double - это (вероятно) 64-битное значение. Вы не можете хранить 256 бит точности в 64 битах. Причина, по которой вы получаете близкое число, заключается в том, что числа с плавающей запятой хранятся с разной точностью - не все последовательные числа могут быть представлены, но вы можете представлять очень большие числа. В данном случае бесполезно. Вы хотите либо использовать библиотеку произвольной точности, либо, поскольку это, вероятно, домашнее задание, вы должны написать свою собственную.

Типичный double, использующий 64-битный IEEE 754, имеет точность около 51 бита, IIRC.

Скорее всего, смысл поддержки показателей до 256 состоит в том, чтобы превысить эту точность, а также точность long double или long long, чтобы вам приходилось делать что-то самостоятельно.

Тогда в качестве домашнего упражнения

• Сохранение значений десятичных цифр в массиве + количество цифр
• Реализовать удвоение значения в таком массиве + счетчик
• Начните с 1 и удвойте значение соответствующее количество раз.

Несколько вещей, о которых вам стоит подумать, чтобы решить эту проблему:

1. Вы имеете дело только с целыми числами, поэтому вы должны использовать целочисленное представление (вам нужно будет свернуть свое собственное, потому что вы не можете использовать long long, который имеет длину "всего" 64 бита).
2. Вы говорите, что степень двойки - как удобно - компьютеры хранят числа, используя степень двойки (вам нужно будет использовать только операции сдвига и возиться с битами ... никакого умножения не потребуется).
3. Как вы можете преобразовать число с основанием 2 в число с основанием 10 для отображения (подумайте о делении и выводе одного числа за раз (подумайте о том, что делает аппаратный делитель, чтобы получить правильные манипуляции с битами).

Вы не можете хранить 256 бит точности в 64 битах. Причина, по которой вы получаете закрывающееся число, заключается в том, что числа с плавающей запятой хранятся с разной точностью. Для всех могут быть представлены порядковые числа, но вы можете представлять очень большие числа. В данном случае бесполезно.