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

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