tipo - ¿Manejar grandes números en C++?
tipos de datos en c (9)
¿Estás buscando cómo realizar operaciones en las grandes entradas que recibes? Hay una gran biblioteca C ++ entera (similar a Java) que le permite realizar operaciones aritméticas ...
¿Cuál es la mejor manera de manejar entradas numéricas grandes en C ++ (por ejemplo, 10^100 )?
Para los algoritmos usualmente cambio a ruby y algunas veces uso cadenas.
¿Algún otro buen método?
Como ya han señalado otros, hay varias bibliotecas bignum / arbitrary precision en C ++ que probablemente encuentres útiles. Si la velocidad no es necesaria, tengo la impresión de que Python y Lisp usan bignums por defecto.
Es posible que desee echar un vistazo a gmplib , una biblioteca de manejo de números de precisión arbitraria para C y C ++
Si quiere que sea precisa, necesita una biblioteca hecha para manejar grandes cantidades. Java tiene BigInt que siempre será preciso, sin importar cuántos dígitos quieras llevar, y proporciona operaciones matemáticas sobre ellos. Se incluye todo el código fuente, se puede transferir, pero este no es el tipo de cosa en la que C ++ es mejor: usaría un lenguaje basado en JVM y usaría una de las bibliotecas Big.
No creo que use Ruby para esto a menos que quieras que sea lento, y supongo que ya que estás hablando de C ++, la velocidad es algo así como una consideración de diseño.
asumiendo que está hablando de ingresar números, la doble precisión lo llevaría a 1.7976931348623157 x 10 ^ 308
Si desea crear su propio código para este propósito intente usar cadenas para almacenar números grandes ... puede crear operaciones básicas como + - / * en ellos ... por ejemplo -
#include <iostream>
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)<<endl;
return 0;
}
Bueno, creo que la mejor manera de hacer dicho cálculo aritmético es mediante el uso de cadenas. ¡Da entrada como argumentos de línea de comando y luego manipula toda la lógica usando funciones de cadena como atoi() e itoa() ! Pero, ¿pueden hacer esto para la multiplicación y la división? Creo que de esta manera, la strlen de strings introducidos no tiene importancia para la programación del compilador hasta que la lógica esté bien.
Consulte el Estudio de caso de enteros grandes en C ++. Pdf de Owen Astrachan. Encontré este archivo extremadamente útil con la introducción de detalles y la implementación del código. No usa ninguna biblioteca de terceros. Lo he usado para manejar números enormes (siempre y cuando tenga suficiente memoria para almacenar el vector<char> ) sin problemas.
Idea : Implementa una clase entera de precisión arbitraria al almacenar big int en un vector<char> .
vector<char> myDigits; // stores all digits of number
Entonces, todas las operaciones relacionadas con el int grande, incluyendo <<, >>, +, -, *, ==, <, !=, >, etc. , se pueden hacer en base a las operaciones en este char array .
Gusto del código : Aquí está el archivo de encabezado, puede encontrar su cpp con códigos en el archivo pdf.
#include <iostream>
#include <string> // for strings
#include <vector> // 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<char> 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);