In this article, we’ll take a look at implementing the itoa() function in C/C++.

This is a useful utility function which converts an integer into a null-terminated string.

However, it isn’t supported natively by most compilers, as it is not a part of the C standard.

Therefore, let’s take a look at using this function, by implementing it ourselves!.

## Basic Syntax of the itoa() function in C/C++

While this function may be available in some compilers, there is no function as such, in most of them.

The itoa() function takes in an integer `num`

, and stores it into `buffer`

. It also has an optional parameter `base`

, which converts it into the appropriate base.

By default, `base`

is set to 10 (decimal base).

After populating `buffer`

, it returns a pointer to the first character of `buffer`

, if the conversion is successful. Otherwise, it returns `NULL`

.

1 |
char* itoa(int num, char* buffer, int base) |

Since there isn’t any default `itoa()`

function in most common C compilers, let’s implement it!

## Implementing the itoa() function in C / C++

We’ll take a number, and convert it to a string. We’ll consider both positive and negative integers, and see how `itoa()`

handles them.

Although some websites may have implemented `itoa()`

by evaluating the digits from right to left and then reversing the string, we’ll use a different approach. t

We’ll evaluate the digits from left to right, with the help of certain function from the `<math.h>`

library.

We’ll follow the below procedure:

- Find the number of digits of
`num`

. If`num`

is positive, we know that the number of digits will be`floor(log(num, base)) + 1`

. (Hint: This is pretty easy to derive using logarithms). - If
`num`

is negative, we will only consider the case where`base = 10`

, since we may need to use separate algorithms to evaluate for any base. We need to put the minus sign as the first digit! - Start from the leftmost (highest) digit of
`num`

, and keep adding the value to the buffer.

The complete program is shown below. You may be able to understand this better by reading through the code!

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
#include <stdio.h> #include <math.h> #include <stdlib.h> char* itoa(int num, char* buffer, int base) { int curr = 0; if (num == 0) { // Base case buffer[curr++] = '0'; buffer[curr] = ''; return buffer; } int num_digits = 0; if (num < 0) { if (base == 10) { num_digits ++; buffer[curr] = '-'; curr ++; // Make it positive and finally add the minus sign num *= -1; } else // Unsupported base. Return NULL return NULL; } num_digits += (int)floor(log(num) / log(base)) + 1; // Go through the digits one by one // from left to right while (curr < num_digits) { // Get the base value. For example, 10^2 = 1000, for the third digit int base_val = (int) pow(base, num_digits-1-curr); // Get the numerical value int num_val = num / base_val; char value = num_val + '0'; buffer[curr] = value; curr ++; num -= base_val * num_val; } buffer[curr] = ''; return buffer; } int main() { int a = 1234; char buffer[256]; if (itoa(a, buffer, 10) != NULL) { printf("Input = %d, base = %d, Buffer = %sn", a, 10, buffer); } int b = -231; if (itoa(b, buffer, 10) != NULL) { printf("Input = %d, base = %d, Buffer = %sn", b, 10, buffer); } int c = 10; if (itoa(c, buffer, 2) != NULL) { printf("Input = %d, base = %d, Buffer = %sn", c, 2, buffer); } return 0; } |

**Output**

1 2 3 |
Input = 1234, base = 10, Buffer = 1234 Input = -231, base = 10, Buffer = -231 Input = 10, base = 2, Buffer = 1010 |

**NOTE**: If you’re compiling with `gcc`

, use the `-lm`

flag to include the math library.

1 |
gcc -o test.out test.c -lm |

Indeed, we were able to get it working. Not only did this work for integers, but only for other bases too!

## Conclusion

Hopefully you were able to get an understanding to converting integers to strings using `itoa()`

, and possibly even implemented one yourself, using this guide!

For similar content, do go through our tutorial section on C programming