долго и мало не хватает и двойной не сработает

0

Я использую C++ и я слышал и испытал, что максимальное значение, которое может быть сохранено в int и long, одинаково.

Но моя проблема в том, что мне нужно сохранить число, превышающее максимальное значение long переменной. Размер double переменной достаточно.

Но проблема заключается в использовании double переменной, избегая меня с помощью оператора % который необходим для более легкого кода моей функции, а иногда нет других способов, кроме как использовать его.

Итак, пожалуйста, любезно скажите мне, как достичь моей цели?

  • 0
    32-разрядное целое число со знаком имеет максимальное значение 2147483647. Вам этого мало?
  • 0
    unsigned int или int64_t / uint64_t, если необходимо.
Показать ещё 1 комментарий
Теги:

6 ответов

6

Это зависит от цели. Для лучшего ответа дайте нам больше контекста

Взгляните на (unsigned) long long или GMP

  • 1
    Если библиотека GMP не соответствует вашим требованиям лицензирования (не каждый может принять LGPL), существует множество других математических библиотек произвольной точности .
  • 0
    проблема в том, что long long не поддерживается с языком c ++, хотя это нормально с c
3

Вы можете использовать тип long long int или unsigned long long int

Чтобы узнать максимальное значение, которое может содержать тип untegral, вы можете использовать следующую конструкцию, например

std::numeric_limits<long long>::max();

Чтобы использовать его, вы должны включить заголовок <limits>

1
#include <cmath>

int main ()
{
    double max_uint = 4294967295.0;
    double max1 = max_uint + 2.0;
    double max2 = (max1 + 1.0) * (max_uint + 1.0);
    double f = fmod(max2,max1);

    return 0;
}

max1 и max2 оба превышают значение unsigned int limit, а fmod возвращает правильный результат max2 % max1, который также превышает предел unsigned int: f == max_uint + 1.0.

Редактировать:

хороший намек от anatolyg: этот метод работает только для целых чисел до 2 ^ 52. Это связано с тем, что мантисса двойника имеет 52 бит, и каждое высшее целое представляется только с точностью потери. Например, 2 ^ 80 может быть == (2 ^ 80) +1 и == (2 ^ 80) +2 и т.д. Чем выше целые числа, тем выше значение inprecision, потому что там расширяется плотность представляемых целых чисел.

Но если вам просто нужно иметь 20 дополнительных бит по сравнению с int с 32 бит, и у вас нет другой возможности достичь этого со встроенным интегральным типом (с которым обычный процент будет быстрее, я думаю), то вы можете использовать это...

  • 1
    Этот метод работает, но он молча теряет точность для больших значений (выше 2 ^ 52 или около того), что может быть неприятным сюрпризом.
  • 0
    @anatolyg хорошая мысль!
1

Итак, вы хотите вычислить по модулю больших целых чисел. Вероятно, 99% вы используете шифрование, что сложно. Ваш вопрос подразумевает, что, возможно, вам стоит найти какое-то готовое решение для вашей проблемы на верхнем уровне (шифрование).

В любом случае стандартным ответом является использование библиотеки для целых чисел с большой точностью, таких как GNU MP.

  • 0
    Есть много других применений для больших чисел, кроме шифрования! Кроме того, стандартный ответ long long , а не GMP.
0

вот список некоторых размеров, которые вы ожидаете в C++:

char      : 1 byte
short     : 2 bytes
int       : 4 bytes
long      : 4 bytes
long long : 8 bytes

float  : 4 bytes
double : 8 bytes 

Я думаю, это ясно объясняет, почему вы испытываете трудности и дает вам подсказку о том, как их решить

  • 0
    Вы не можете сравнивать целочисленные типы и типы с плавающей запятой по их байтам относительно хранения целых чисел: даже 4-байтовое число с плавающей запятой может хранить намного более высокие целые числа как 8-байтовый длинный ...
  • 0
    Я добавил только float и double в качестве ссылки; ответ на самом деле относится к целочисленным типам
Показать ещё 1 комментарий
0

сначала существует разница между int и длинным типом

но для того, чтобы исправить вашу проблему, вы можете использовать

unsigned long long int

Ещё вопросы

Сообщество Overcoder
Наверх
Меню