INT_MAX e INT_MIN en C/C++ y Aplicaciones

La mayoría de las veces, en la programación competitiva, existe la necesidad de asignar la variable, el valor máximo o mínimo que puede contener el tipo de datos, pero recordar un número tan grande y preciso resulta ser un trabajo difícil. Por lo tanto, C++ tiene ciertas macros para representar estos números, de modo que estos puedan asignarse directamente a la variable sin tener que escribir el número entero.

Según el compilador y el estándar C++, es posible que deba incluir el archivo de encabezado <limits.h> o <climits> en su código fuente C o C++, respectivamente. Por lo tanto, es recomendable incluir este archivo de encabezado para usar las macros INT_MAX, INT_MIN. Para obtener más información sobre este archivo de encabezado, consulte este artículo . 

INT_MAX es una macro que especifica que una variable entera no puede almacenar ningún valor más allá de este límite. 
INT_MIN especifica que una variable entera no puede almacenar ningún valor por debajo de este límite.

Values of INT_MAX and INT_MIN may vary
from compiler to compiler. Following are
typical values in a compiler where integers
are stored using 32 bits.

Value of INT_MAX is +2147483647.
Value of INT_MIN is -2147483648.

// C++ program to print values of INT_MAX
// and INT_MIN
#include <bits/stdc++.h>
using namespace std;
int main()
{
    cout << INT_MAX << endl;
    cout << INT_MIN;
    return 0;
}

// C program to print values of INT_MAX
// and INT_MIN
// we have to include limits.h for results in C
#include <limits.h>
#include <stdio.h>
int main()
{
    printf("%d\n", INT_MAX);
    printf("%d", INT_MIN);
}

2147483647
-2147483648

Aplicaciones de INT_MAX e INT_MIN: 

1. Verifique el desbordamiento de enteros: 

// C++ code to check for Integer overflow while
// adding 2 numbers
#include <bits/stdc++.h>
 
// Function to check integer overflow
int check_overflow(int num1, int num2)
{
    // Checking if addition will cause overflow
    if (num1 > INT_MAX - num2)
        return -1;
 
    // No overflow occurred
    else
        return num1 + num2;
}
 
// Driver code
int main()
{
    // The sum of these numbers will equal INT_MAX
    // If any of them is incremented by 1, overflow
    // will occur
    int num1 = 2147483627;
    int num2 = 20;
 
    // Result is -1 if overflow occurred
    // Stores the sum, otherwise
    int result = check_overflow(num1, num2);
 
    // Overflow occurred
    if (result == -1)
        std::cout << "Integer overflow occurred";
 
    // No overflow
    else
        std::cout << result;
}

// C code to check for Integer overflow while
// adding 2 numbers
 
#include <stdio.h>
#include <limits.h>
 
// Function to check integer overflow
int check_overflow(int num1, int num2)
{
    // Checking if addition will cause overflow
    if (num1 > INT_MAX - num2)
        return -1;
 
    // No overflow occurred
    else
        return num1 + num2;
}
 
int main(void)
{
    // The sum of these numbers will be equivalent to INT_MAX
    // If any of them is incremented by 1, overflow will occur
   
    int num1 = 2147483627;
    int num2 = 20;
 
    // Result is -1 if overflow occurred
    // Stores the sum, otherwise
    int result = check_overflow(num1, num2);
 
    // Overflow occurred
    if (result == -1)
        printf("Integer overflow occurred");
 
    // No overflow
    else
        printf("%d", result);
}
 
// This code is contributed by sarajadhav12052009

2147483647

De manera similar, podemos verificar el desbordamiento al restar 2 números usando INT_MIN.

2. Cálculo de MIN en una array con elementos grandes 
Normalmente asignamos un valor alto a MIN para calcular el valor mínimo en una array. Pero si una array tiene elementos grandes, debemos asignar el valor más alto posible a la array.

A continuación se muestra la implementación de C++: 

// C++ code to compute MIN element
#include <bits/stdc++.h>
 
// Function to compute minimum element in array
int compute_min(int arr[], int n)
{
    // Assigning highest value
    int MIN = INT_MAX;
 
    // Traversing and updating MIN
    for (int i = 0; i < n; i++)
        MIN = std::min(MIN, arr[i]);
 
    // Printing MIN element
    std::cout << MIN;
}
 
// Driver code
int main()
{
    // array with MIN to compute
    int arr[] = { 2019403813, 2147389580, 2145837140,
                  2108938594, 2112076334 };
 
    // size of array
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function call to compute MIN
    compute_min(arr, n);
}

2019403813

De manera similar, MAX se puede encontrar en una array de números grandes usando INT_MIN.

Este artículo es una contribución de Rohit Thapliyal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.