Cómo convertir Char Array a Int en C++

Un array char terminado en nulo puede contener texto que representa un entero. C++ ofrece varias formas de analizar ese texto, pero las funciones difieren en cómo informan de los errores y en si aceptan un prefijo numérico seguido de otros caracteres. Elige el método según si la entrada es de confianza y si todo el array debe contener un número válido.

Los ejemplos usan entrada decimal. Convertir correctamente un prefijo no significa necesariamente que se hayan consumido todos los caracteres: por ejemplo, analizar "23323tail" puede producir 23323 y dejar tail sin analizar. Si toda la entrada debe ser numérica, comprueba la posición final del análisis además del resultado de la conversión.

Usa la función std::strtol para convertir un array char en un int

std::strtol analiza una secuencia de caracteres terminada en nulo y devuelve un long. Su tercer argumento selecciona la base: usa 10 para decimal, 16 para hexadecimal o 0 para inferirla a partir de un prefijo. Para las bases distintas de cero, el rango válido va de 2 a 36.

El segundo argumento recibe un puntero al primer carácter que no se consumió. Si todavía apunta al inicio de la entrada, no se analizaron dígitos. Si apunta al carácter nulo final, se consumió la cadena completa. Antes de llamar a la función, asigna cero a errno y después comprueba si contiene ERANGE para detectar un resultado fuera del rango de long. Como el resultado es un long, antes de guardarlo en un int compáralo también con std::numeric_limits<int>::min() y max().

Ejecuta este ejemplo. Usa texto decimal almacenado en un array de caracteres terminado en nulo e imprime el entero analizado.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

#include <cerrno>
#include <cstdlib>
#include <iostream>
#include <limits>

int main() {
  const char input[] = "23323";
  char* end = nullptr;
  errno = 0;
  const long parsed = std::strtol(input, &end, 10);

  if (end == input || *end != '\0' || errno == ERANGE ||
      parsed < std::numeric_limits<int>::min() ||
      parsed > std::numeric_limits<int>::max()) {
    std::cout << "Could not convert the complete input.\n";
    return 0;
  }

  const int value = static_cast<int>(parsed);
  std::cout << value << '\n';
}

La ejecución proporcionada para este caso correcto terminó con el código 0 y produjo:

23323

La ejecución solo cubre esta entrada válida; no demuestra qué ocurre con conversiones fallidas ni con valores fuera de rango. Conserva estas comprobaciones en el código de producción: permiten distinguir entre la ausencia de conversión, los caracteres sobrantes, un error de rango de long y un valor que no cabe en int.

Usa la función std::atoi para convertir un array char en un int

std::atoi es una opción concisa cuando la entrada ya es de confianza y tiene el formato correcto:

int value = std::atoi(input);

Acepta espacios en blanco iniciales y un signo opcional, y después analiza los dígitos decimales. Como otros analizadores de prefijos, puede detenerse ante un carácter que no sea un dígito e ignorar el resto. No ofrece una forma fiable de distinguir un cero válido de una conversión fallida ni un canal útil para informar de errores de rango. Si el valor analizado no se puede representar como int, el comportamiento no está definido; no uses std::atoi con entradas numéricas no comprobadas o que no sean de confianza. Usa std::strtol si la entrada puede estar mal formada o fuera de rango, o si quien llama necesita diagnósticos de conversión y una comprobación explícita del rango de int.

Usa la función std::sscanf para convertir un array char en un int

std::sscanf aplica un formato al texto e indica cuántas conversiones se realizaron correctamente. Para un entero, comprueba que el valor devuelto sea 1 antes de usar el destino:

int value = 0; int converted = std::sscanf(input, "%d", &value);

%d acepta espacios en blanco iniciales y un signo opcional, y después lee dígitos decimales. Puede analizar correctamente un prefijo y dejar texto sobrante sin leer; si necesitas consumir toda la entrada, añade una comprobación de formato o usa otro método de análisis. El destino debe ser un objeto int real y escribible, y no debes leerlo a menos que el recuento confirme que se realizó una conversión. Ese recuento no hace seguro un resultado que no pueda representarse: si el valor coincidente no cabe en int, el comportamiento no está definido. No uses %d con entradas numéricas no comprobadas o que no sean de confianza y puedan estar fuera de rango. Para esta tarea sencilla, std::strtol hace más explícitas las comprobaciones de posición final y de rango.

Usa un bucle para convertir un array char en un int

Un bucle es apropiado cuando la sintaxis aceptada es deliberadamente personalizada. Define primero esa sintaxis. Por ejemplo, un analizador decimal podría aceptar un + o - inicial opcional, exigir al menos un dígito y rechazar cualquier otro carácter. También debe comprobar, antes de cada operación de multiplicación y suma, que el siguiente dígito no haga que el valor supere el rango elegido para el entero. De lo contrario, el desbordamiento de un entero con signo puede producir un resultado incorrecto o provocar un comportamiento no definido.

No omitas caracteres que no sean dígitos para añadir los dígitos posteriores: convertir "23tail4" en 234 es filtrar caracteres, no analizar un entero. Un analizador personalizado completo debe gestionar la posición del signo, validar los dígitos, consumir toda la entrada y comprobar el desbordamiento. Si no necesitas esas reglas personalizadas, usa std::strtol y su puntero de posición final.

Conclusión

Para una conversión general, prefiere std::strtol: proporciona la posición donde se detuvo el análisis y permite detectar errores de rango de long; además, antes de la conversión se puede comparar su resultado con los límites de int. Usa std::atoi solo con entradas de confianza y bien formadas, cuando no necesites diagnósticos detallados. Elige std::sscanf cuando resulte útil analizar con un formato y comprueba el recuento de conversiones. Escribe un bucle si el programa necesita una gramática de entrada deliberadamente distinta e implementa de forma explícita las comprobaciones del signo, los dígitos, el consumo completo y el desbordamiento.