Как сделать сложение чисел состоящих из нескольких целых чисел - PullRequest
Новая
       76

Как сделать сложение чисел состоящих из нескольких целых чисел

0 голосов
/ 01 апреля 2020

В настоящее время я пытаюсь реализовать программу, которая может вычислять некоторые криптографические функции c ha sh. Я нахожусь в процессе создания класса BigInt, который, я надеюсь, позволит мне выполнять операции basi c math и logi c с целыми числами произвольного размера.

Часть класса, над которым я работаю: 

class BigInt
{
  std::vector<unsigned int> num;
  BigInt operator+ (BigInt num_to_add)
  {
    //Implementation
  }
}

Я надеюсь, что есть какой-то способ добавить целые числа без знака и получить бит переполнения, а также способ передать этот бит переполнения следующему целому числу, как я полагаю, на ассемблере что код операции в ARM Assembly - это «ADCS», который устанавливает бит переполнения, а также принимает бит переполнения и переносит его в следующую сумму сложения. Однако я искал вокруг, и я не могу найти какую-либо функциональность для этого в языке C ++.

Редактировать: На всякий случай, если кто-нибудь наткнется на это, вот моя реализация функции добавления. 

class big_int
{
    public:
    std::vector<unsigned int> num;
    big_int(std::vector<unsigned int> num)
    {
        this->num = num;
    }
    big_int operator+ (unsigned int num_to_add)
    {
        bool carry_flag = true;
        std::vector<unsigned int> output_num;
        for (unsigned int num_part : num)
        {
            unsigned int value = num_part;
            if(carry_flag)
            {
                value = num_part + num_to_add;
            }
            else
            {
                value = num_part;
            }
            carry_flag = false;
            if (value < num_to_add || value < num_part)
            {
                carry_flag = true;
                num_to_add = 1;
                output_num.push_back(value);
            }
            else
            {
                output_num.push_back(value);
            }
        }
        if (carry_flag)
        {
            output_num.push_back(1);
        }
        big_int out_obj(output_num);
        return out_obj;
    }
    big_int operator+ (big_int num_to_add)
    {
        int smallest_size;
        int largest_size;
        std::vector<unsigned int> largest_num;
        if (num.size() > num_to_add.num.size())
        {
            largest_size = num.size();
            smallest_size = num_to_add.num.size();
            largest_num = num;
        }
        else
        {
            largest_size = num_to_add.num.size();
            smallest_size = num.size();
            largest_num = num_to_add.num;
        }
        bool carry_flag = false;
        std::vector<unsigned int> out_num;
        for(int i = 0; i < smallest_size; i++)
        {
            unsigned int num_a = num[i];
            unsigned int num_b = num_to_add.num[i];
            unsigned int result;
            if (carry_flag)
            {
                result = num_a + num_b + 1;
            }
            else
            {
                result = num_a + num_b;
            }
            carry_flag = false;
            if (result < num_a || result < num_b)
            {
                carry_flag = true;
            }
            out_num.push_back(result);
        }
        std::vector<unsigned int> rest_of_largest_num;
        if (smallest_size == largest_size)
        {
            if (carry_flag)
            {
                out_num.push_back(1);
            }
        }
        else
        {
            for(int i = smallest_size; i < largest_size; i++)
            {
                rest_of_largest_num.push_back(largest_num[i]);
            }
            if (carry_flag)
            {
                big_int rest_of_largest_num_obj(rest_of_largest_num);
                rest_of_largest_num_obj = rest_of_largest_num_obj + 1;
                rest_of_largest_num = rest_of_largest_num_obj.num;
            }
        }
        for (int i = 0; i < rest_of_largest_num.size(); i++)
        {
            out_num.push_back(rest_of_largest_num[i]);
        }
        big_int out_obj(out_num);
        return out_obj;
    }
};

1 Ответ

0 голосов
/ 01 апреля 2020

Как сделать сложение чисел, состоящих из нескольких целых чисел

Помните в школе, когда вы добавляете числа, как это? 

       1
  1234567
+  123456
  ......3

Это алгоритм это используется с произвольной точностью математики. Вместо 0,9 каждый член будет иметь диапазон unsigned int (в вашем случае).

Я надеюсь, что есть какой-то способ добавить целые числа без знака и получить бит переполнения

Нет способа получить доступ к биту переполнения в C ++. Учтите, что не у всех процессоров есть такая функция.

...