what happens if stoi fails

Daniel Parker

3 min read

·

23-02-2025

1

0

Share

The C++ standard library function std::stoi is a powerful tool for converting strings to integers. However, if the input string isn't a valid integer representation, things can go wrong. Understanding how std::stoi handles failures and implementing robust error handling is crucial for writing reliable C++ code. This article will explore what happens when std::stoi encounters an invalid input and provide best practices for managing these situations.

Understanding std::stoi and its Potential for Failure

std::stoi (short for "string to integer") attempts to parse a string and convert it into an integer type (typically int, long, or long long). It's convenient for tasks like reading numerical data from user input or configuration files. However, the function can fail if the string doesn't adhere to the expected format.

Here are some scenarios that can lead to std::stoi failure:

• Non-numeric characters: If the string contains characters other than digits ('0' - '9'), a plus sign ('+'), or a minus sign ('-'), the conversion will fail. For example, "123a" or "abc" will cause an error.
• Overflow: If the string represents an integer value that is too large or too small to be represented by the target integer type, an overflow will occur leading to undefined behavior. For example, converting "9999999999999999999999" to a standard int will likely overflow.
• Empty string: An empty string ("") will also cause a failure.

How std::stoi Signals Failure

Unlike functions that might return an error code, std::stoi throws an exception when it encounters an invalid input. Specifically, it throws an exception of type std::invalid_argument if the input string is improperly formatted, and std::out_of_range if an overflow occurs.

Ignoring these exceptions can lead to unpredictable program crashes. Therefore, it's essential to handle them using try-catch blocks.

Best Practices for Handling std::stoi Errors

The recommended approach for using std::stoi involves a try-catch block to gracefully handle potential exceptions:

#include <iostream>
#include <string>
#include <stdexcept>

int main() {
  std::string inputString;
  int number;

  std::cout << "Enter an integer: ";
  std::cin >> inputString;

  try {
    number = std::stoi(inputString);
    std::cout << "You entered: " << number << std::endl;
  } catch (const std::invalid_argument& e) {
    std::cerr << "Invalid input: " << e.what() << std::endl;
  } catch (const std::out_of_range& e) {
    std::cerr << "Number out of range: " << e.what() << std::endl;
  }

  return 0;
}

This code first prompts the user for input. Then, it uses a try block to attempt the conversion using std::stoi. If an exception is thrown (either std::invalid_argument or std::out_of_range), the corresponding catch block handles it, providing informative error messages to the user or logging the error appropriately.

Alternative Approaches: std::strtol for More Control

For more granular control over error handling and overflow detection, consider using std::strtol instead of std::stoi. std::strtol provides additional information about the conversion process through its return value and its errno parameter.

#include <iostream>
#include <cstdlib> // for strtol
#include <cerrno>  // for errno
#include <cstring> // for strerrror

int main() {
  char* endptr;
  char inputString[] = "123abc";
  long number;
  errno = 0;  // Reset errno before calling strtol

  number = std::strtol(inputString, &endptr, 10);

  if (endptr == inputString) {
    std::cerr << "No digits were found" << std::endl;
  } else if (errno == ERANGE) {
    std::cerr << "Number out of range: " << std::strerror(errno) << std::endl;
  } else if (*endptr != '\0') {
      std::cerr << "Invalid character found after number: " << *endptr << std::endl;
  } else {
    std::cout << "Number: " << number << std::endl;
  }

  return 0;
}

std::strtol returns the converted long integer. If an error occurs it will return zero or a value dependent on the error. Examining errno after the function call can provide more specifics about the error.

Conclusion

When working with std::stoi, always use try-catch blocks to handle potential exceptions. This prevents unexpected program termination and ensures robust error handling in your C++ applications. For finer control and more information about errors, std::strtol provides an alternative approach. Remember to choose the approach that best suits your application's needs and error-handling strategy.