c++ - sirve - unsigned char c

¿Qué tipo de usar para enteros mayores a 2 ^ 32 en C++?

Question

Tengo una variable entera, que puede obtener un valor mayor que 4294967295.

¿Qué tipo de uso debo usar (largo largo, doble o algo más)?

Answer 1

¿Qué tan portátil debe ser tu programa? TR1 tiene cstdint y stdint.h por lo que es probable que sea compatible con la mayoría de los compiladores actualizados. Luego está Boost cstdint.hpp que debería poder usar si cstdint no es compatible.

Answer 2

Ambas propuestas no son buenas porque durante mucho tiempo no es un tipo de datos C ++ estándar, y el doble es un punto flotante.

Como mi programa debe ser portátil, voy a # definir mis propios tipos, que se adapten a todos los compiladores que uso (Visual Studio y gcc):

#ifdef WIN32
  #define unsigned_long_long unsigned __int64
  #define long_long __int64
#else // gcc. Might not work on other compilers!
  #define unsigned_long_long unsigned long long
  #define long_long long long
#endif

Answer 3

Los dobles son de coma flotante. Deberías usar long long, probablemente. No sé qué alias es el preferido.

Answer 4

Muchos compiladores actuales de C / C ++ tienen el encabezado stdint.h o inttypes.h.

int_fast64_t o int64_t puede ser una opción (en mi humilde opinión, la más portátil).

Answer 5

No existe una forma portátil de hacerlo en C ++, ya que el idioma no especifica el tamaño de los tipos enteros (excepto sizeof char es 1). Debe consultar su documentación del compilador.

Answer 6

No use doble porque:

cout.setf(ios::fixed);
cout << LONG_LONG_MAX << endl;
cout << double(LONG_LONG_MAX) << endl;

cout << LONG_LONG_MAX-100 << endl;
cout << double(LONG_LONG_MAX-100) << endl;

Salida:

9223372036854775807
9223372036854775808.000000
9223372036854775707
9223372036854775808.000000

Answer 7

Prueba TTMath . Todo lo que necesita hacer es incluir un solo encabezado y luego declarar un tipo de bignum como:

typedef ttmath::UInt<100> BigInt;

que crea un tipo que puede contener enteros sin signo entre 0 y 2 ^ (32 * 100) -1. Entonces solo usa BigInt donde quiera que uses int .

Por supuesto, puede elegir el tamaño que desee para el parámetro de la plantilla. 100 podría ser exagerado ;-)

Solo me di cuenta, la lib solo funciona en x86 y x64, pero es un sistema operativo multiplataforma en esos procesadores.

Answer 8

Si tu compilador no tiene mucho tiempo, puedes implementarlo tú mismo con una estructura que contenga dos largos, pero necesitarás ser cuidadoso con el transporte, etc. Por supuesto, podrías buscar una aritmética de precisión múltiple como GMP.

Answer 9

Tratar:

http://gmplib.org/ big num.

http://mattmccutchen.net/bigint/ big int.

No he usado ninguno, pero he usado cosas similares en Java.

Answer 10

Use long long y, si es posible, agregue una afirmación en tiempo de compilación de que este tipo es lo suficientemente ancho (muy similar a sizeof( long long ) >= 8 ).

double es para coma flotante, no entero.

Answer 11

si no necesita números negativos, los sonidos largos sin signo suenan como la mayoría de los que puede obtener.

Answer 12

yo suelo

uint64_t

Pero no es estándar.

Answer 13

Voy a suponer que tus números caben en 64 bits. Si no es así, entonces necesita una biblioteca aritmética de precisión arbitraria , como GMP .

En teoría, no existe una manera fácil y portátil de realizar cálculos matemáticos de 64 bits en C ++. En la práctica, la mayoría de los compiladores de C ++ también admiten los encabezados de C "anticuados", y C99 tiene un buen encabezado llamado stdint.h .

Entonces, primero hazlo:

#include <stdint.h>

Luego use los tipos int64_t (signed) y uint64_t (unsigned).

Answer 14

Solo por curiosidad: no creo que sea demasiado difícil codificar el tuyo si quisieras. Quiero decir, todos estos tipos de datos tienen estructuras predefinidas, por supuesto, pero podrías, por ejemplo, usar la estructura double que usa exponentes, y hacer algo como esto:

para mantener un número MUY grande, más allá de la escala de un doble, crea un objeto que tiene dos partes: el número y la potencia a diez,

entonces, si quisieras almacenar algo como

1.1230123123 x 10 ^ (100000000000000000000000000000000000), que no es compatible con un doble, puede tener la parte 1.123 ... almacenada en un doble, y luego la potencia de diez como un doble / int / flotante separado (lo que sea adecuado), y luego tomarlo desde allí. Por supuesto, esta puede no ser la mejor manera, y probablemente tendrías que codificar con mucha funcionalidad para división, resta, etc., pero definitivamente sería portátil, ya que estarías usando los tipos de datos normales definidos. La utilidad de esto dependerá de lo que esté tratando de lograr y de si planea usarlo más allá de un solo proyecto, pero creo que es una forma confiable de hacerlo si ese tipo de números son un requisito absoluto.