C++, Qt, OpenGL, CUDA

Adapter le type des variables utilisées permet d'optimiser la mémoire en fonction des besoins, mais cela à un impact sur les valeurs que peut prendre un type donné. Il est donc indispensable d'avoir un moyen pour obtenir des informations détaillées sur les types numériques.

Pour cela, le C++ propose un ensemble de fonctionnalités dans le fichier d'en-tête limits. Ces fonctionnalités sont un peu particulières, ce sont des classes génériques, leur syntaxes utilisent des chevrons. Une telle classe, permettant d'obtenir des informations sur un type, est appelée une classe de traits. Vous allez voir dans ce chapitre comment utiliser ce type de classes, leur création sera abordé dans la partie sur la programmation objet.

Par exemple, connaître la valeur maximale que peut prendre le type int, il faut utiliser la syntaxe suivante :

main.cpp

#include <iostream>
#include <limits>
 
int main() {
    std::cout << "Max(int) = " << std::numeric_limits<int>::max() << std::endl;
}

La classe de traits numeric_limits est une classe générique, qui prend un type en paramètre (int, entre chevrons). Et on appelle la fonction max de cette classe. Le résultat affiché sera :

Max(int) = 2147483647 ou 7fffffff

Cette valeur maximale signifie concrètement que lorsque vous utiliser une variable de type int pour compter, vous ne pourrez compter que jusqu'à 2147483647. Au delà, le compte ne sera plus correcte (en pratique, il reviendra à une valeur négative) :

main.cpp

#include <iostream>
 
int main() {
    int i { 2147483645 };
    std::cout << i << std::endl;
    ++i;
    std::cout << i << std::endl;
    ++i;
    std::cout << i << std::endl;
    ++i;
    std::cout << i << std::endl;
    ++i;
    std::cout << i << std::endl;
}

affiche :

2147483645
2147483646
2147483647
-2147483648
-2147483647

Comme vous le savez déjà, le C++ est permissif, il n'interdira pas ce code. C'est à vous de vérifier que vous ne dépasser pas la valeur maximale possible pour un type.

On peut alors vérifier les valeurs maximales pour les différents types numériques :

main.cpp

#include <iostream>
#include <limits>
 
int main() {
    int const char_max { std::numeric_limits<char>::max() };
    std::cout << "Max(char) = " << char_max << std::endl;
    int const unsigned_char_max { std::numeric_limits<unsigned char>::max() };
    std::cout << "Max(unsigned char) = " << unsigned_char_max << std::endl;
    std::cout << "Max(short int) = " << std::numeric_limits<short int>::max() << std::endl;
    std::cout << "Max(unsigned short int) = " << std::numeric_limits<unsigned short int>::max() << std::endl;
    std::cout << "Max(int) = " << std::numeric_limits<int>::max() << std::endl;
    std::cout << "Max(unsigned int) = " << std::numeric_limits<unsigned int>::max() << std::endl;
    std::cout << "Max(long int) = " << std::numeric_limits<long int>::max() << std::endl;
    std::cout << "Max(unsigned long int) = " << std::numeric_limits<unsigned long int>::max() << std::endl;
 
    std::cout << std::endl;
    std::cout << "Max(float) = " << std::numeric_limits<float>::max() << std::endl;
    std::cout << "Max(double) = " << std::numeric_limits<double>::max() << std::endl;
    std::cout << "Max(long double) = " << std::numeric_limits<long double>::max() << std::endl;
}

Pour les types char et unsigned char, pour éviter que cout ne les affiche comme des caractères, les valeurs maximales sont enregistrées dans une variable de type int avant d'être affichées.

Le code précédent affiche :

Max(char) = 127
Max(unsigned char) = 255
Max(short int) = 32767
Max(unsigned short int) = 65535
Max(int) = 2147483647
Max(unsigned int) = 4294967295
Max(long int) = 9223372036854775807
Max(unsigned long int) = 18446744073709551615
Max(long long int) = 9223372036854775807
Max(unsigned long long int) = 18446744073709551615

Max(float) = 3.40282e+38
Max(double) = 1.79769e+308
Max(long double) = 1.18973e+4932

Comme on s'y attend, plus un type est large en mémoire, plus sa valeur maximale sera élevée. On peut remarquer aussi que les types long int et long long int, qui ont la même taille mémoire (8 octets), ont la même valeur maximale. De même pour les versions unsigned de ces types. Pour terminer, on peut aussi remarquer que les types unsigned ont des valeurs maximales plus grandes que le type signé correspondant.

Pour obtenir les valeurs minimales d'un type, il faut utiliser les fonctions min et lowest à la place de max. Cependant, ces fonctions ne retournent pas exactement la même chose, selon que l'on utilise un type entier ou un type réel.

Commençons par les types entiers. Dans ce cas, les deux fonctions retournent la même valeur, qui correspond à la plus petite valeur que peu prendre un type. Pour les types non signées, cette valeur sera toujours 0 et pour les types signés, cette valeur sera -max-1 :

main.cpp

#include <iostream>
#include <limits>
 
int main() {
    int const char_min { std::numeric_limits<char>::min() };
    std::cout << "Min(char) = " << char_min << std::endl;
    std::cout << "Min(short int) = " << std::numeric_limits<short int>::min() << std::endl;
    std::cout << "Min(int) = " << std::numeric_limits<int>::min() << std::endl;
    std::cout << "Min(long int) = " << std::numeric_limits<long int>::min() << std::endl;
}

affiche :

Min(char) = -128
Min(short int) = -32768
Min(int) = -2147483648
Min(long int) = -9223372036854775808

Concrètement, cela veut dire, par exemple pour une variable de type int, que l'on peut compter de -2147483648 à 2147483647. Et pour un type unsigned int que l'on peut compter de 0 à 4294967295.

Dans le cas des nombres réels, les fonctions min et lowest ne retournent pas la même valeur.

• min retourne la plus petite valeur positive non nulle (la plus petite valeur proche de 0) ;
• lowest retourne la plus petite valeur, donc -max.

En mathématique, quelque soit $x$ appartenant à l'ensemble des nombres réels positifs non nul $\mathbb{R}^*_+$, il existe toujours un nombre plus petit que $x$ (on peut démontrer cela facilement, on montrant que $\frac x 2$ est strictement compris entre 0 et $x$). Ce qui revient à dire qu'il n'existe pas de plus petit nombre positif non nul.

En informatique, la situation est différente. Un nombre en mémoire est représenté par un nombre fini de bits, par exemple 32 pour float ou 64 bits pour double. Dans cette situation, il ne sera pas possible

digits ? digits10 ? max_digits10 ? radix ?

• is_signed
• is_integer
• is_exact
• min
• max
• lowest
• epsilon

• is_nan
• is_finite
• is_infinite

max, min, epsilon, etc

représentation des nombres entier négatif

limitation de représentation d'un nombre “réel” par une représentation limité en mémoire