C ++ Types de variable Limites

(liée à c, mais je pense que cela s'applique également à C ++)

Vous pouvez également essayer " Inquire ", qui est un script qui peut Re-Créez des limites.h pour votre compilateur. Une citation de la page d'accueil de ProJetC:

Ceci est un programme qui détermine beaucoup propriétés du compilateur C et machine qu'il est exécutée, comme minimum et maximum [ONU] signé Char / int / Long, de nombreuses propriétés de flotteur / [long] double, et ainsi de suite.

comme une option qu'il produit l'ANSI C float.h et limites.h fichiers.

comme une autre option, cela vérifie même que le compilateur lit l'en-tête fichiers correctement.

C'est un bon test de test pour les compilateurs, depuis cela les exerce avec beaucoup limiter les valeurs, telles que le minimum et nombre maximal de points flottants.

#include <limits>

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

Je vois que la réponse "correcte" a déjà été donnée: Utilisez code> et laissez la magie se produire. Je trouve que la réponse insatisfaisante, car la question est la suivante:

serait-il vraiment difficile d'écrire une méthode pour calculer la limite d'un type de variable? B> P>

La réponse est: facile pour les types entier, durs pour les types de flotteurs. Il y a 3 types d'algorithmes de base dont vous auriez besoin pour faire cela. point signé, non signé et flottant. chacun a un algorithme différent pour la manière dont vous obtenez le min et max, et le code réel implique un peu de twiddling, et dans le cas de point flottant, vous devez faire boucle à moins que vous n'ayez un type d'entier connu qui a la même taille que le flotteur Tapez. P>

Alors, le voici. P>

Unsigné est facile. Le min est lorsque tous les bits sont 0, le maximum est lorsque tous les bits sont 1. p> xxx pré>

pour signé, le minute est lorsque le bit de signalisation est défini mais tous les autres Les bits sont des zéros, le maximum est lorsque tous les bits sauf le bit de signalisation sont définis. sans savoir savoir la taille du type, nous ne savons pas où le bit des signes est, mais nous pouvons utiliser quelques astuces de bits pour que cela fonctionne pour fonctionner. p> xxx pré>

pour flotter Point, il y a 4 limites, bien que, bien que connu que seules les limites positives soient suffisantes, les limites négatives ne sont que des signer des limites positives inversées. Il existe potentiellement plusieurs façons de représenter des nombres de points flottants, mais pour ceux qui utilisent un point flottant binaire (plutôt que la base 10), presque tout le monde utilise des représentations IEEE. P>

pour les flotteurs IEEE, la plus petite valeur de point flottant positif est Lorsque le bit de l'exposant est faible et que tous les autres bits sont 0. La plus grande valeur de point flottante négative est l'inverse des bits d'inverse. Cependant, sans type entier connu pour avoir la même taille que le type de point flottant donné, il n'ya aucun moyen de faire cette manipulation de bits autre que d'exécuter une boucle. Si vous avez un type d'entier que vous connaissez a la même taille que votre type de point flottant, vous pouvez le faire comme une seule opération. P>

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.
   }