Question: Right now I'm working on a project which requires an integer to be converted to a base 62 string many times a second. The faster this conversion is completed, the better.

The problem is that I'm having a hard time getting my own base conversion methods to be fast *and* reliable. If I use strings, it's generally reliable and works well, but it's slow. If I use char arrays, it's generally much faster, but it's also very messy, and unreliable. (It produces heap corruption, comparison of strings that should match return a negative, etc.)

So what's the fastest and most reliable way of converting from a very large integer to a base 62 key? In the future, I plan on utilizing SIMD model code in my application, so is this operation parallelizable at all?

EDIT: This operation is performed several million times a second; as soon as the operation finishes, it begins again as part of a loop, so the faster it runs, the better. The integer being converted is of arbitrary size, and can easily be as large as a 128 bit integer (or larger).

EDIT: This is the function I am currently using.

```
char* charset = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
int charsetLength = (int)(strlen(charset));

//maxChars is an integer specifying the maximum length of the key
char* currentKey = new char[maxChars];

void integerToKey(unsigned long long location)
{
    unsigned long long num = location;
    int i = 0;

    for(; num > 0; i++)
    {
            currentKey[i] = charset[num % (charsetLength)];
            num /= charsetLength + 1;
    }

    currentKey[i + 1] = '\0';
}

```

I ripped this out of a class that is part of my application, and some of the code is modified so that it makes sense sans its owning class.

Answer: 
Your implementation is pretty much as quick as it's going to get. I would suggest a couple of changes though:

```
void integerToKey(unsigned long long location)
{
    unsigned long long num = location;
    int i = 0;
    for(; num > 0; i++)
    {
            currentKey[i] = charset[num % (charsetLength)];
            num /= charsetLength; // use charsetLength
    }
    currentKey[i] = '\0'; // put the null after the last written char
}

```

The first change (divide by `charsetLength`) may have been causing your string comparison problems. With your original code (dividing by `charsetLength + 1`), there may be different values of integer that incorrectly get converted to the same string. For base 62, then both 0 and 62 would be encoded as `"0"`.

It's hard to say whether either of the above changes would be causing your reported heap corruption problems, without a bit more context (such as the value of `maxChars`).

Also, you should be aware that the above code will write the digits of the string representation in reverse order (try it with base 10 and convert a number such as 12345 to see what I mean). This may not matter for your application, though.
I'm piling on with another answer because a couple of answers I tried didn't produce the output I expected. Though, this is optimized for readability, not speed.

```
string toStr62(unsigned long long num) {
   string charset = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
   int base = charset.length();
   string str = num ? "" : "0";

   while (num) {
      str = charset.substr(num % base, 1) + str;
      num /= base;
   }

   return str;
}

```