Manipulando números grandes em C ++?

Qual é a melhor maneira de manipular grandes inputs numéricas em C ++ (por exemplo, 10^100 )?

Para algoritmos, geralmente mudo para ruby ​​e às vezes uso strings.

Algum outro bom método?

    Parece que você está procurando uma maneira de inserir números de Precisão Arbitrária. aqui estão duas bibliotecas que você pode usar: GMP e MAPM

    Confira o estudo de caso inteiro grande em C ++ pdf por Owen Astrachan. Eu encontrei este arquivo extremamente útil com introdução de detalhes e implementação de código. Não usa nenhuma biblioteca de terceiros. Eu usei isso para lidar com números enormes (contanto que você tenha memory suficiente para armazenar vector ) sem problemas.


    Idéia : Implementa uma class inteira de precisão arbitrária armazenando big int em um vector .

     vector myDigits; // stores all digits of number 

    Então, todas as operações relacionadas ao big int, incluindo <<, >>, +, -, *, ==, <, !=, >, etc. , podem ser feitas com base nas operações nesta char array .


    Gosto do código : Aqui está o arquivo de header, você pode encontrar seu cpp com códigos no arquivo pdf.

     #include  #include  // for strings #include  // for sequence of digits using namespace std; class BigInt { public: BigInt(); // default constructor, value = 0 BigInt(int); // assign an integer value BigInt(const string &); // assign a string // may need these in alternative implementation // BigInt(const BigInt &); // copy constructor // ~BigInt(); // destructor // const BigInt & operator = (const BigInt &); // assignment operator // operators: arithmetic, relational const BigInt & operator += (const BigInt &); const BigInt & operator -= (const BigInt &); const BigInt & operator *= (const BigInt &); const BigInt & operator *= (int num); string ToString() const; // convert to string int ToInt() const; // convert to int double ToDouble() const; // convert to double // facilitate operators ==, <, << without friends bool Equal(const BigInt & rhs) const; bool LessThan(const BigInt & rhs) const; void Print(ostream & os) const; private: // other helper functions bool IsNegative() const; // return true iff number is negative bool IsPositive() const; // return true iff number is positive int NumDigits() const; // return # digits in number int GetDigit(int k) const; void AddSigDigit(int value); void ChangeDigit(int k, int value); void Normalize(); // private state/instance variables enum Sign{positive,negative}; Sign mySign; // is number positive or negative vector myDigits; // stores all digits of number int myNumDigits; // stores # of digits of number }; // free functions ostream & operator <<(ostream &, const BigInt &); istream & operator >>(istream &, BigInt &); BigInt operator +(const BigInt & lhs, const BigInt & rhs); BigInt operator -(const BigInt & lhs, const BigInt & rhs); BigInt operator *(const BigInt & lhs, const BigInt & rhs); BigInt operator *(const BigInt & lhs, int num); BigInt operator *(int num, const BigInt & rhs); bool operator == (const BigInt & lhs, const BigInt & rhs); bool operator < (const BigInt & lhs, const BigInt & rhs); bool operator != (const BigInt & lhs, const BigInt & rhs); bool operator > (const BigInt & lhs, const BigInt & rhs); bool operator >= (const BigInt & lhs, const BigInt & rhs); bool operator <= (const BigInt & lhs, const BigInt & rhs); 

    Você está procurando como realizar operações nas grandes inputs que recebe? Existe uma grande biblioteca C ++ inteira (semelhante a Java) que permite executar operações aritméticas …

    Se você quiser criar seu próprio código para o propósito tente usar strings para armazenar números grandes … você pode então criar operações básicas como + – / * nelas … por exemplo –

     #include  using namespace std; string add (string &s1, string &s2){ int carry=0,sum,i; string min=s1, max=s2, result = ""; if (s1.length()>s2.length()){ max = s1; min = s2; } else { max = s2; min = s1; } for (i = min.length()-1; i>=0; i--){ sum = min[i] + max[i + max.length() - min.length()] + carry - 2*'0'; carry = sum/10; sum %=10; result = (char)(sum + '0') + result; } i = max.length() - min.length()-1; while (i>=0){ sum = max[i] + carry - '0'; carry = sum/10; sum%=10; result = (char)(sum + '0') + result; i--; } if (carry!=0){ result = (char)(carry + '0') + result; } return result; } int main (){ string a,b; cin >> a >> b; cout << add (a,b)< 

    supondo que você está falando sobre a introdução de números, a precisão dupla iria levá-lo até 1.7976931348623157 x 10 ^ 308

    Você pode querer dar uma olhada no gmplib , uma biblioteca de manipulação de números de precisão arbitrária para C e C ++

    Se você quer que seja preciso, você precisa de uma biblioteca feita para lidar com grandes números. Java tem BigInt que sempre será preciso, não importa quantos dígitos você queira levar, e fornece operações matemáticas neles. Todo o código-fonte está incluído, você poderia transferi-lo, mas este não é o tipo de coisa em que o C ++ é melhor – eu usaria uma linguagem baseada em JVM e usaria uma das grandes bibliotecas.

    Eu não acho que eu usaria Ruby para isso, a menos que você quisesse que fosse lento, e eu estou assumindo que, desde que você está falando sobre C ++, a velocidade é um pouco de uma consideração de design.

    Como outros já apontaram, existem várias bibliotecas de precisão bignum / arbitrárias em C ++ que você provavelmente acharia úteis. Se a velocidade não é necessária, tenho a impressão de que o Python e o Lisp usam bignums por padrão.

    Bem, eu acho que a melhor maneira de fazer esse cálculo aritmético é usando strings. Dê input como argumentos de linha de comando e manipule a lógica inteira usando funções de string como atoi() e itoa() ! Mas, isso pode ser feito para multiplicação e divisão? Eu acho que desta forma strlen de strings entrou não importa para a programação para o compilador até que a lógica está bem.