Articles

How to Convert a String to an Integer in C++

Learn how to convert strings to integers in C++ using methods like `std::stoi()`, `std::istringstream()`, `atoi()`, `strtol()`, `sscanf()`, and manual conversion using a `for` loop.

Why convert strings to integers in C++?

In programming, receiving numbers as strings is common, especially when taking user input or reading from files. For example, a user might enter their age as "25" or the price of an item as "123". We must first convert these strings into integers to perform any mathematical operations, comparisons, or logical checks.

C++ offers several ways to convert a string to an integer, each with syntax, advantages, and limitations. Let’s begin by exploring these methods one by one.

Related Course

Learn C#: References

Unlock the power of references, an essential aspect of object-oriented programming in C#. Try it for free

Convert string to integer using stoi()

The std::stoi() function (short for “string to integer”) provides a modern and efficient way to convert a string into an integer in C++. It features an easy-to-implement and understand syntax. As part of the C++ Standard Library, std::stoi includes built-in error handling to manage invalid or out-of-range inputs, making it a reliable choice for most use cases.

Syntax:

int std::stoi(const std::string& str, size_t* idx = 0, int base = 10);

Parameters:

  • str: The input string to convert.

  • idx (Optional): A pointer to a size_t variable where the function stores the index of the first character not processed.

  • base (Optional): Numerical base (e.g., 10 for decimal, 16 for hexadecimal). The default is 10.

Example:

Let’s look at an example to see how we can use stoi() to convert a string into an integer while handling exceptions for invalid input: 

#include <iostream> 
#include <string>  


int main() {  
  std::string str = "123"; // Input string 
  try {  
    // Convert string to integer  
    int num = std::stoi(str);  
    std::cout << "The integer is: " << num << std::endl;  
  } catch (const std::invalid_argument&) {  
    std::cout << "Invalid input: The string is not a valid number." << std::endl;  
  } catch (const std::out_of_range&) {  
    std::cout << "Number out of range." << std::endl;  
  } 
  return 0;  
}

Output: 

The integer is: 123

Why use the stoi()?

  • Pros: Easy to use, supports optional base conversion, and includes built-in error handling.

  • Cons: Throws exceptions (std::invalid_argument, std::out_of_range), which may introduce overhead in performance-critical code.

Next, let’s look at how istringstream offers a more flexible approach to string-to-integer conversion, especially when dealing with more complex inputs or extracting multiple values from a string.

String to int conversion using istringstream()

std::istringstream is part of the <sstream> library and is a flexible tool for extracting data from strings. This method is beneficial when dealing with strings that contain mixed types of data, such as "123 apples", or when multiple values need to be parsed from the same string.

Syntax: 

std::istringstream iss(const std::string& str);  
iss >> variable;

Parameters:

  • str: The input string from which to extract data.

  • variable: The variable to save the extracted integer.

Example:

The following example shows how istringstream() extracts an integer from a string: 

#include <iostream> 
#include <sstream> 
 
int main() { 
  std::string str = "456"; // Input string 
  std::istringstream iss(str); 
  int num; 
 
  // Extract the integer from the string 
  iss >> num; 
 
  if (iss.fail()) { 
    std::cout << "Conversion failed: Invalid input." << std::endl; 
  } else { 
      std::cout << "The integer is: " << num << std::endl; 
  } 
 
  return 0; 
}

Here,

  • std::istringstream iss(str): Initializes a string stream object using the input string str.

  • iss >> num: Extracts the integer value from the string and stores it in the variable num.

  • iss.fail(): Checks if the extraction failed (e.g., if the string contains non-numeric characters).

Output: 

The integer is: 456

Why use istringstream()?

  • Pros: Ideal for parsing strings with mixed content, such as “456 apples,” and is highly useful when extracting multiple values from a single string.

  • Cons: Slightly more verbose than std::stoi for simple integer conversion tasks.

If you’re looking for a more straightforward method for converting strings to integers without parsing complex content, let’s explore atoi().

How to use atoi() to convert strings to integers

atoi() (ASCII to integer) is a legacy function inherited from the C programming language. It converts a C-style string (const char*) into an integer. While it’s simple and efficient, atoi() does not include error handling, making it less reliable for use in modern C++ applications.

Syntax: 

int atoi(const char* str);

Parameters:

  • str: The C-style string to convert.

Example:

This example demonstrates how to use atoi() to convert a string into an integer: 

#include <iostream> 
#include <cstdlib> 
 
int main() { 
  const char* str = "789"; // Input C-style string 
  int num = atoi(str); 
  std::cout << "The integer is: " << num << std::endl; 
  return 0; 
}

Output: 

The integer is: 789

Why use atoi()?

  • Pros: Straightforward and fast to implement.

  • Cons: It does not handle errors. It returns 0 for invalid input, which may cause programs using this function to behave unexpectedly.

If there is a need for C-style conversion with better error handling than atoi(), the strtol() function offers a safer and more flexible alternative.

Convert string to integer using strtol()

The strtol() (string to long) method offers a more robust process for converting strings into integers compared to atoi(). It provides better error handling and can parse strings that contain a mix of numeric and non-numeric characters.

Syntax: 

long int strtol(const char* str, char** endptr, int base);

Parameters:

  • str: The C-style string to convert.

  • endptr: Pointer to the character where conversion stopped.

  • base: The numeric base (e.g., 10 for decimal).

Example:

This example converts a string to an integer and identifies where parsing stopped: 

#include <iostream> 
#include <cstdlib> 
 
int main() { 
  const char* str = "123abc"; // Input string 
  char* endptr; 
  int num = strtol(str, &endptr, 10); 
 
  // Check where parsing stopped 
  if (*endptr != '\0') { 
    std::cout << "Conversion stopped at: " << endptr << std::endl; 
  } else { 
    std::cout << "The integer is: " << num << std::endl; 
  } 
 
  return 0; 
}

Output: 

Conversion stopped at: abc

Why use strtol()?

  • Pros: Safer than atoi() as it handles partially valid strings like “123abc” and lets you track where parsing fails.

  • Cons: Syntax slightly more complex than stoi().

If there is a preference for a C-style function that combines simplicity with formatted input capabilities, let’s look at how sscanf() can convert strings to integers.

Convert string to integer with sscanf()

The sscanf() function, from the <cstdio> library, is a C-style function that reads formatted data from a string. Extracting values based on a known format, such as integers, floats, or strings, is beneficial.

Syntax: 

int sscanf(const char* str, const char* format, ...);

Parameters:

  • str: The input C-style string.

  • format: Format specifier (e.g., %d for integers).

  • ...: Variable(s) to store the parsed data. Variables must be passed by pointer (e.g., &num).

Example:

This example demonstrates how to use sscanf() to convert the string into an integer: 

#include <iostream>  
#include <cstdio>  
 
int main() {  
  const char* str = "789";  
  int num;  
 
  if (sscanf(str, "%d", &num) == 1) {  
    std::cout << "The integer is: " << num << std::endl;  
  } else {  
    std::cout << "Conversion failed: Invalid input." << std::endl;  
  }  
  return 0;  
}

Output: 

The integer is: 789

Why use sscanf()?

  • Pros: It is flexible for parsing formatted strings and can extract multiple values at a time.

  • Cons: It is a C-style function with less type-safety.

The for loop method offers a manual approach to string-to-integer conversion, allowing full control without relying on C-style functions.

Manual string to integer conversion using for loop

This manual approach converts a numeric string to an integer by processing one character at a time. It involves explicitly handling each character and incrementally building the final integer.

Syntax: 

for (char c : str) {  
  num = num * 10 + (c - '0');  
}

Parameters:

  • str: Input string containing numeric characters.

  • c: Each character in the string.

  • num: The resulting integer after processing the characters.

Example:

This example demonstrates how to manually convert the string “456” to an integer using a for loop: 

#include <iostream>  
#include <string>   
 
int main() { 
  std::string str = "456"; // Input string  
 
  int num = 0;  
  // Convert string to integer manually  
  for (char c : str) {  
    // Check for invalid characters  
    if (c < '0' || c > '9') {  
      std::cout << "Invalid character in input." << std::endl;  
      return 1;  
    }  
 
     // Build the integer step by step  
     num = num * 10 + (c - '0');  
    }  
    std::cout << "The integer is: " << num << std::endl;  
    return 0;  
}

Output: 



The integer is: 456

Why use a for loop?

  • Pros: It offers complete control over the conversion process and can be customized for special needs (e.g., filtering or validating input in unique ways).

  • Cons: More error-prone and verbose than built-in functions like stoi(). Less efficient for general use.

Now that we’ve reviewed the methods, let’s examine their strengths, weaknesses, and best practices in specific situations.

C++ string to integer conversion: Which method should you use?

Let’s compare different methods and see which is fastest for string to integer conversion.

Method Pros Cons Best Use Case
stoi() Simple, efficient, robust error handling. Throws exceptions that require handling. Converting straightforward numeric strings.
istringstream() Good for parsing mixed content. Verbose compared to alternatives. Extracting integers from strings with mixed data.
atoi() Fast and simple. No error handling, deprecated in modern C++. Legacy code.
strtol() Handles partially valid strings. Slightly complex syntax. Converting strings with trailing or mixed characters.
sscanf() Flexible and good for formatted string. Verbose and less type-safe. Parsing strings with a defined pattern.
For loop Full control over conversion. Manual and error-prone. Teaching and learning conversion logic.

Conclusion

In this article, we explored several ways to convert strings to integers in C++, including modern methods like stoi() and istringstream(), legacy C-style functions such as atoi(), strtol(), and sscanf(), as well as a manual for loop-based approach. Each method serves different needs, whether it’s safety, flexibility, simplicity, or fine-grained control, making it important to choose based on your specific context.

Explore Codecademy’s Learn C++ course to practice these concepts hands-on and gain a deeper understanding of string handling, parsing, and C++ fundamentals.

Frequently asked questions

1. What is the best way to convert a string to an integer in C++?

The best method depends on your needs. For most modern applications, std::stoi is preferred due to its simplicity and exception-based error handling. If you’re parsing mixed content or need more control, std::istringstream or strtol may be more suitable.

2. How does std::stoi handle invalid input during conversion?

std::stoi throws a std::invalid_argument exception if no conversion can be performed, and a std::out_of_range exception if the value is outside the range of representable integers, making it safer than older methods like atoi.

3. Can I use atoi() in modern C++ code?

Yes, but it’s not recommended. atoi() lacks error handling, returning 0 for invalid input, which can lead to incorrect program behavior. Prefer std::stoi or strtol for better safety and clarity.

4. What is the difference between strtol and sscanf for string conversion?

Both can parse numbers from strings, but strtol provides better error checking through its endptr argument, whereas sscanf is more flexible for formatted input but less safe and modern.

5. Why would someone manually convert a string to an integer using a for loop?

Manual conversion offers full control, such as validating character sets or customizing logic. However, it’s more error-prone and verbose compared to built-in functions and usually used for educational or specialized use cases.

Codecademy Team

'The Codecademy Team, composed of experienced educators and tech experts, is dedicated to making tech skills accessible to all. We empower learners worldwide with expert-reviewed content that develops and enhances the technical skills needed to advance and succeed in their careers.'

Meet the full team

Related articles

Learn more on Codecademy

Contents