límites tipos variables C ++

Question

aquí es una pregunta bastante simple (creo), ¿existe un método de biblioteca STL que proporciona el límite de un tipo de variable (por ejemplo, número entero) ? sé que estos límites difieren en equipos diferentes pero tiene que haber una manera de conseguir a través de un método, ¿verdad?

Además, ¿sería muy difícil escribir un método para calcular el límite de un tipo de variable?

Sólo por curiosidad! :)

Gracias;).

Answer 1

std::numeric_limits :

// numeric_limits example
// from the page I linked
#include <iostream>
#include <limits>
using namespace std;

int main () {
  cout << boolalpha;
  cout << "Minimum value for int: " << numeric_limits<int>::min() << endl;
  cout << "Maximum value for int: " << numeric_limits<int>::max() << endl;
  cout << "int is signed: " << numeric_limits<int>::is_signed << endl;
  cout << "Non-sign bits in int: " << numeric_limits<int>::digits << endl;
  cout << "int has infinity: " << numeric_limits<int>::has_infinity << endl;
  return 0;
}

Answer 2

veo que la respuesta 'correcta' ya se ha dado: Uso <limits> y dejar que la magia suceda. Da la casualidad de encontrar que poco satisfactoria respuesta, ya que la pregunta es:

¿sería muy difícil escribir un método para calcular el límite de un tipo de variable?

La respuesta es: fácil para los tipos enteros, dura para este tipo de flotador. Hay 3 tipos básicos de algoritmos que se necesitan para hacer esto. firmado, sin signo y coma flotante. cada uno tiene un algoritmo diferente de cómo se obtiene el mínimo y el máximo, y el código real implica algún cambio de bit, y en el caso de coma flotante, hay que bucle menos que tenga un tipo conocido entero que es del mismo tamaño que el flotador tipo.

Por lo tanto, aquí está.

Sin signo es fácil. el min es cuando todos los bits son 0 de, el máximo es cuando todos los bits son 1'S.

const unsigned type unsigned_type_min = (unsigned type)0;    
const unsigned type unsigned_type_max = ~(unsigned type)0;

Para firmado, el min es cuando el bit de signo se establece pero todos los demás bits son ceros, el máximo es cuando se fijan todos los bits excepto el bit de signo. sin necesidad de conocer el tamaño del tipo, no sabemos donde el bit de signo es, pero podemos utilizar algunos trucos poco para conseguir que esto funcione.

const signed type signed_type_max = (signed type)(unsigned_type_max >> 1);
const signed type signed_type_min = (signed type)(~(signed_type_max));

para coma flotante, hay 4 límites, aunque knowning sólo los límites positivos es suficiente, los límites negativos son simplemente signo invertido límites positivos. Hay un medio potencialmente muchas maneras de representar números en coma flotante, pero para los que el uso binario (en lugar de la base 10) de punto flotante, todo el mundo utiliza casi IEEE representaciones.

Para IEEE flota, el valor de punto flotante positivo más pequeño es cuando el bit bajo del exponente es 1 y todos los demás bits son 0 de. El valor de punto flotante negativo más grande es la inversa de este bit a bit. Sin embargo, sin un tipo entero que se sabe que es del mismo tamaño que el tipo de punto flotante dado, no hay ninguna manera de hacer esto manipulación de bits aparte de la ejecución de un bucle. si usted tiene un tipo entero que sabe que es del mismo tamaño que el tipo de punto flotante, se puede hacer esto como una sola operación.

const float_type get_float_type_smallest() {
   const float_type float_1 = (float_type)1.0;
   const float_type float_2 = (float_type)0.5;
   union {
      byte ab[sizeof(float_type)];
      float_type fl;
      } u;
   for (int ii = 0; ii < 0; ++ii)
      u.ab[ii] = ((byte*)&float_1)[ii] ^ ((byte*)&float_2)[ii];
   return u.fl;
   }

const float_type get_float_type_largest() {
   union {
      byte ab[sizeof(float_type)];
      float_type fl;
      } u;
   u.fl = get_float_type_smallest();
   for (int ii = 0; ii < 0; ++ii)
      u.ab[ii] = ~u.ab[ii];
   return -u.fl; // Need to re-invert the sign bit.
   }

Answer 3

(relacionado con C, pero creo que esto también se aplica para C ++)

También puede probar " investigan ", que es un script que puede re-crear limits.h para su compilador. Una cita de la página principal del projetc:

  

Este es un programa que determina muchas   propiedades del compilador C y   máquina que se ejecuta en, como   mínimo y máximo [un] firmado   char / INT / tiempo, muchas de las propiedades   flotador / [largo] doble, y así sucesivamente.

     

Como una opción que produce el ANSI C   float.h y archivos limits.h.

     

Como otra opción, incluso cheques   que el compilador lee el encabezado   archivos correctamente.

     

Es una buena prueba de los casos para los compiladores,   ya que los ejerce con muchas   valores límite, como el mínimo   y los números de punto flotante máximo.

Answer 4

#include <limits>

std::numeric_limits<type>::max() // min() etc