Diferencia entre std::numeric_limits<T> min, max y lower en C++

La clase std::numeric_limits<T> en el encabezado de límite proporciona la función min() , max() y lower() para todos los tipos de datos numéricos junto con las otras funciones miembro .

std::numeric_limits<T>::max(): El std::numeric_limits<T>::max() para cualquier tipo T proporciona el valor finito máximo representable por el tipo numérico T . Entonces, la función max() da un valor x para un tipo de datos T tal que no hay otro valor finito y donde y > x .

Tanto para los tipos enteros como para los tipos de datos de punto flotante, la función max() proporciona el valor más grande que se puede representar y no hay otro valor que se encuentre a la derecha de este valor en la recta numérica.

std::numeric_limits<T>::lowest(): El std::numeric_limits<T>::lowest() para cualquier tipo T es el valor finito más bajo representable por el tipo numérico T , tal que no hay otro valor finito y donde y > x .

Tanto para los tipos enteros como para los tipos de datos de punto flotante, la función más bajo() proporciona el valor mínimo que se puede representar y no hay otro valor que se encuentre a la izquierda de este valor en la recta numérica. La función lower() es básicamente el valor negativo de max() .

std::numeric_limits<T>::min(): El std::numeric_limits<T>::min() para cualquier tipo T es el valor finito mínimo representable por el tipo numérico T . Entonces, la función min () es el valor más pequeño posible que puede ser representado por el tipo T.

Para los tipos de punto flotante con desnormalización, la función min() devuelve el valor normalizado positivo mínimo. Como la función min() devuelve el valor normalizado positivo mínimo para los tipos de punto flotante, el exponente del valor no puede ser 0 .

Para obtener el valor anormal mínimo positivo, use std::numeric_limits<T>::denorm_min() . denorm_min() es solo para tipos de punto flotante y para tipos enteros da 0.

Para tipos enteros min() un alias de la función lower() , lo que significa que ambos dan el mismo valor finito más bajo. Si min() de valores enteros se hubiera definido de forma similar a los tipos de coma flotante, ese valor habría sido 1.

Por ejemplo:

A continuación se muestra el programa para ilustrar los conceptos anteriores:

// C++ program to illustrate difference
// between the numeric limits min, max,
// and the lowest
  
#include <bitset>
#include <iostream>
#include <limits>
using namespace std;
  
// Driver Code
int main()
{
    int x;
  
    // Size of int
    cout << "int " << sizeof(int)
         << " bytes" << endl;
  
    // numeric_limits<int>::max()
    x = numeric_limits<int>::max();
    cout << "\tmax :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << x << endl;
  
    // numeric_limits<int>::lowest()
    x = numeric_limits<int>::lowest();
    cout << "\tlowest :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << x << endl;
  
    // numeric_limits<int>::min()
    x = numeric_limits<int>::min();
    cout << "\tmin :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << x << endl;
  
    // numeric_limits<int>::denorm_min()
    x = numeric_limits<int>::denorm_min();
    cout << "\tdenorm_min :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << x << endl;
  
    cout << endl;
  
    // Size of float
    cout << "float " << sizeof(float)
         << " bytes" << endl;
    float f;
  
    // numeric_limits<int>::max()
    f = numeric_limits<float>::max();
  
    // read the binary representation
    // of the float as an integer
    x = *(int*)&f;
  
    cout << "\tmax :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << f << endl;
  
    // numeric_limits<int>::lowest()
    f = numeric_limits<float>::lowest();
    x = *(int*)&f;
  
    cout << "\tlowest :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << f << endl;
  
    // numeric_limits<int>::min()
    f = numeric_limits<float>::min();
    x = *(int*)&f;
    cout << "\tmin :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << f << endl;
  
    // numeric_limits<int>::denorm_min()
    f = numeric_limits<float>::denorm_min();
    x = *(int*)&f;
    cout << "\tdenorm_min :" << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << f << endl;
  
    return 0;
}

int 4 bytes
    max :
01111111111111111111111111111111
2147483647
    lowest :
10000000000000000000000000000000
-2147483648
    min :
10000000000000000000000000000000
-2147483648
    denorm_min :
00000000000000000000000000000000
0

float 4 bytes
    max :
01111111011111111111111111111111
3.40282e+38
    lowest :
11111111011111111111111111111111
-3.40282e+38
    min :
00000000100000000000000000000000
1.17549e-38
    denorm_min :
00000000000000000000000000000001
1.4013e-45

Nota: En C++ , la precisión predeterminada es 6, lo que significa que se utilizan hasta 6 dígitos significativos para representar el número y, por ese motivo, el número real no será el mismo que el valor impreso. Para obtener el valor real para tratar de establecer una mayor precisión.

A continuación se muestra el programa para ilustrar lo mismo:

// C++ program to illustrate the
// above concepts
  
#include <bitset>
#include <iomanip>
#include <iostream>
#include <limits>
using namespace std;
  
// Driver Code
int main()
{
    // Output is not exact
    cout << "\tlowest :" << endl
         << numeric_limits<float>::lowest()
         << endl;
  
    // The value from the output
    float f = -3.40282e+38;
    int x = *(int*)&f;
    cout << bitset<8 * sizeof(x)>(x)
         << endl
         << endl;
  
    // Correct value
    f = numeric_limits<float>::lowest();
    x = *(int*)&f;
    cout << "\tnumeric_limits<float>::lowest() :"
         << endl
         << bitset<8 * sizeof(x)>(x)
         << endl
         << endl;
  
    cout << "\tusing setprecision:"
         << endl;
  
    // output is more precise
    cout << setprecision(10) << f << endl;
  
    // The value from the output
    f = -3.402823466e+38;
  
    // Read the binary representation
    // of the float as an integer
    x = *(int*)&f;
  
    cout << bitset<8 * sizeof(x)>(x)
         << endl;
  
    return 0;
}

lowest :
-3.40282e+38
11111111011111111111111111101110

    numeric_limits::lowest() :
11111111011111111111111111111111

    using setprecision:
-3.402823466e+38
11111111011111111111111111111111