Как я могу складывать и вычитать 128-битные целые числа в C или C ++, если мой компилятор их не поддерживает?

Если все, что вам нужно, это сложение и вычитание, и у вас уже есть 128-битные значения в двоичной форме, библиотека может быть удобна, но не является строго необходимой. Эту математику легко выполнить самостоятельно.

Я не знаю, что ваш компилятор использует для 64-битных типов, поэтому я буду использовать INT64 и UINT64 для 64-битных целых чисел со знаком и без знака.

class Int128
{
public:
    ...
    Int128 operator+(const Int128 & rhs)
    {
        Int128 sum;
        sum.high = high + rhs.high;
        sum.low = low + rhs.low;
        // check for overflow of low 64 bits, add carry to high
        if (sum.low < low)
            ++sum.high;
        return sum;
    }
    Int128 operator-(const Int128 & rhs)
    {
        Int128 difference;
        difference.high = high - rhs.high;
        difference.low = low - rhs.low;
        // check for underflow of low 64 bits, subtract carry to high
        if (difference.low > low)
            --difference.high;
        return difference;
    }

private:
    INT64  high;
    UINT64 low;
};

Взгляните на GMP.

#include <stdio.h>
#include <gmp.h>

int main (int argc, char** argv) {
    mpz_t x, y, z;
    char *xs, *ys, *zs;
    int i;
    int base[4] = {2, 8, 10, 16};

    /* setting the value of x in base 10 */
    mpz_init_set_str(x, "100000000000000000000000000000000", 10);

    /* setting the value of y in base 16 */
    mpz_init_set_str(y, "FF", 16);

    /* just initalizing the result variable */
    mpz_init(z);

    mpz_sub(z, x, y);

    for (i = 0; i < 4; i++) {
        xs = mpz_get_str(NULL, base[i], x);
        ys = mpz_get_str(NULL, base[i], y);
        zs = mpz_get_str(NULL, base[i], z);

        /* print all three in base 10 */
        printf("x = %s\ny = %s\nz = %s\n\n", xs, ys, zs);

        free(xs);
        free(ys);
        free(zs);
    }

    return 0;
}

На выходе

x = 10011101110001011010110110101000001010110111000010110101100111011111000000100000000000000000000000000000000
y = 11111111
z = 10011101110001011010110110101000001010110111000010110101100111011111000000011111111111111111111111100000001

x = 235613266501267026547370040000000000
y = 377
z = 235613266501267026547370037777777401

x = 100000000000000000000000000000000
y = 255
z = 99999999999999999999999999999745

x = 4ee2d6d415b85acef8100000000
y = ff
z = 4ee2d6d415b85acef80ffffff01

Наткнувшись на этот относительно старый пост совершенно случайно, я подумал, что уместно развить предыдущую гипотезу Вольта для неопытных читателей.

Во-первых, подписанный диапазон 128-битного числа составляет от -2 ¹²⁷ до 2 ¹²⁷ -1, а не от -2 ¹²⁷ до 2 ¹²⁷, как было предусмотрено изначально.

Во-вторых, из-за циклической природы конечной арифметики наибольшая требуемая разность между двумя 128-битными числами составляет от -2 ¹²⁷ до 2 ¹²⁷ -1, что требует наличия хранилища 128 бит, а не 129. Хотя (2 ¹²⁷ -1) - (-2 ¹²⁷) = 2 ¹²⁸ -1, что явно больше чем наше максимальное положительное целое число 2 ¹²⁷ -1, арифметическое переполнение всегда гарантирует, что ближайшее расстояние между любыми двумя n -битными числами всегда будет в диапазоне от 0 до 2 ⁿ -1 и, следовательно, неявно от -2 ^{n -1} до 2 ^{n - 1} -1.

Чтобы прояснить ситуацию, давайте сначала рассмотрим, как гипотетический 3-битный процессор будет реализовывать двоичное сложение. В качестве примера рассмотрим следующую таблицу, в которой показан абсолютный беззнаковый диапазон 3-битного целого числа.

0 = 000b
1 = 001b
2 = 010b
3 = 011b
4 = 100b
5 = 101b
6 = 110b
7 = 111b ---> [ Циклический возврат к 000b при переполнении]

Из приведенной выше таблицы легко очевидно, что:

001b (1) + 010b (2) = 011b (3)

Также очевидно, что добавление любого из этих чисел с его числовым дополнением всегда дает 2 ⁿ -1:

010b (2) + 101b ([дополнение 2] = 5) = 111b (7) = (2 ³ -1)

Из-за циклического переполнения, которое происходит, когда сложение двух n -битных чисел приводит к (n +1) -битному результату, отсюда следует, что добавление любого из этих числа с его числовым дополнением + 1 всегда будут давать 0:

010b (2) + 110b ([дополнение 2] + 1) = 000b (0)

Таким образом, мы можем сказать, что [дополнение к n] + 1 = - n, так что n + [дополнение к n ] + 1 = n + (- n) = 0. Кроме того, если мы теперь знаем, что n + [дополнение к n] + 1 = 0, тогда n + [дополнение n - x] + 1 must = n - (n - x) = x.