C ++ limiti tipi variabili

Question

Questa è una domanda molto semplice (credo), c'è un metodo libreria STL che fornisce il limite di un tipo di variabile (ad esempio integer) ? so che questi limiti differiscono su diversi computer, ma ci deve essere un modo per riuscire a superare un metodo, giusto?

Inoltre, sarebbe davvero difficile scrivere un metodo per calcolare il limite di un tipo di variabile?

Sono solo curioso! :)

Grazie;).

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

Vedo che la risposta 'giusta' è già stata data: Usa <limits> e lasciare che la magia accade. Mi capita di scoprire che la risposta insoddisfacente, dal momento che la domanda è:

Sarebbe davvero difficile scrivere un metodo per calcolare il limite di un tipo di variabile?

La risposta è: facile per i tipi interi, duri per i tipi di float. Ci sono 3 tipi fondamentali di algoritmi si avrebbe bisogno di fare questo. firmata, senza segno, e in virgola mobile. ciascuno ha un algoritmo diverso per come si ottiene il minimo e massimo, e il codice effettivo comporta alcuni bit giocherellando, e nel caso di virgola mobile, è necessario ciclo se non si dispone di un tipo noto intero che è la stessa dimensione del galleggiante tipo.

Quindi, eccolo qui.

Unsigned è facile. il minimo è quando tutti i bit sono 0 di, il massimo è quando tutti i bit sono 1 di.

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

Per firmato, il minimo è quando il bit del segno è impostato, ma tutti gli altri bit sono zero, il massimo è quando sono impostati tutti i bit ad eccezione del bit del segno. con fuori conoscere la dimensione del tipo, non sappiamo dove il bit di segno è, ma possiamo usare alcuni trucchi bit per farlo funzionare.

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

per virgola mobile, ci sono 4 limiti, anche se knowning solo i limiti positivi è sufficiente, i limiti negativi sono solo segno invertito limiti positivi. C'è un potenzialmente molti modi per rappresentare numeri in virgola mobile, ma per coloro che utilizzano binario (anziché base 10) in virgola mobile, quasi tutti usano rappresentazioni IEEE.

Per galleggianti IEEE, il valore in virgola mobile positivo più piccolo è quando il bit basso dell'esponente è 1 e tutti gli altri bit sono 0 di. Il valore più grande negativo virgola mobile è l'inverso bit di questo. Tuttavia, senza un tipo intero che è noto per essere la stessa dimensione del dato tipo virgola mobile, non c'è alcun modo per fare questo manipolazione bit diverso esecuzione di un ciclo. se si dispone di un tipo integer che si sa è la stessa dimensione come tipo di virgola mobile, si può fare questo come una singola operazione.

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

(relativo a C, ma credo che questo vale anche per il C ++)

Si può anche provare " informarsi ", che è uno script che può ricreare limits.h per il vostro compilatore. Una citazione dalla home page del projetc:

  

Questo è un programma che determina molti   proprietà del compilatore C e   macchina che viene eseguito su, ad esempio   minima e massima [un] firmato   car / int / lunghi, molte proprietà di   galleggiante / [lungo] doppio, e così via.

     

Come opzione produce l'ANSI C   float.h e file limits.h.

     

Come ulteriore opzione, anche i controlli   che il compilatore legge l'intestazione   file in modo corretto.

     

Si tratta di un buon banco di prova per i compilatori,   dal momento che li esercita con molte   valori limite, come minimo   e numeri massimi in virgola mobile.

Answer 4

#include <limits>

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