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!.

Table of Contents

## 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`

.

```
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!

```
#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] = '\0';
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] = '\0';
return buffer;
}
int main() {
int a = 1234;
char buffer[256];
if (itoa(a, buffer, 10) != NULL) {
printf("Input = %d, base = %d, Buffer = %s\n", a, 10, buffer);
}
int b = -231;
if (itoa(b, buffer, 10) != NULL) {
printf("Input = %d, base = %d, Buffer = %s\n", b, 10, buffer);
}
int c = 10;
if (itoa(c, buffer, 2) != NULL) {
printf("Input = %d, base = %d, Buffer = %s\n", c, 2, buffer);
}
return 0;
}
```

**Output**

```
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.

```
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