convert int (which actually decimal) to string (1234 to "123.4")

Question

I have integer number, for example 1234, but in reality it means 123.4, so it's encoded decimal and I should multiply to 10^-1.

How can I convert this int to string "123.4" easily? I should have "123.4" exactly, not "123.3999999". So I need something like itoa but more advanced.

upd by string I mean char array.

Answer 1

Convert the number to a std::string:

char buffer[12];
std::string s = itoa(1234, buffer, 10);

Or:

std::string s = std::to_string(intNum);

Then simply insert() the decimal character into it:

s.insert(s.length()-1, "."); 

Or:

s.insert(s.length()-1, 1, '.'); 

Answer 2

Dividing by 10 can cause precision loss if the numbers exceed the float point precision of the CPU. Instead, use something like this:

string intNumStr = itoa(intNum);
char lastDigit = intNumStr[intNumStr.length() - 1];
intNumStr[intNumStr.length() - 1] = '.';
intNumStr += string(lastDigit);

Answer 3

I was curious about the relative performance of these conversions so I did a few tests with the naive versions of a few methods. A few notes and caveats:

• The below conversion codes have no error checking and haven't been tested (i.e., don't copy/paste the code).
• Some methods only work for positive integers.
• The methods do not have equivalent output. For example numbers 0-9 ('0.0', '.0', '.') and factors of 10 ('10', '10.', '10.0'). You should decide exactly what output you want for these cases.
• I would start by choosing the simplest algorithm and only optimize once it is found I need to. Do you really need performance of ~100 million integers/second?
• Unfortunately, I don't have a C++11 compiler to test the std::to_string() versions.

Algorithms tested are:

string toString1 (const int a)
{
    char buffer[32];
    string result = itoa(a, buffer, 10);
    char lastDigit = result[result.length() - 1];
    result[result.length() - 1] = '.';
    result += lastDigit;

    return result;
}

void toString1a (string& Output, const int a)
{
    char buffer[32];
    Output = itoa(a, buffer, 10);
    char lastDigit = Output[Output.length() - 1];
    Output[Output.length() - 1] = '.';
    Output += lastDigit;
}

string toString2 (const int a) {
    float f = a * 0.1f;
    ostringstream ss;
    ss << f;

    return ss.str();
}    

const char* toString3 (const int a)
{
    static char s_buffer[32]; //Careful!

    itoa(a, s_buffer, 10);
    size_t len = strlen(s_buffer);
    char lastDigit = s_buffer[len-1];
    s_buffer[len-1] = '.';
    s_buffer[len] = lastDigit;
    s_buffer[len+1] = '\0';

    return s_buffer;
}    

const char* toString4 (char* pBuffer, const int a)
{
    itoa(a, pBuffer, 10);
    size_t len = strlen(pBuffer);
    char lastDigit = pBuffer[len-1];
    pBuffer[len-1] = '.';
    pBuffer[len] = lastDigit;
    pBuffer[len+1] = '\0';

    return pBuffer;
}

void toString4a (char* pBuffer, const int a)
{
    itoa(a, pBuffer, 10);
    size_t len = strlen(pBuffer);
    char lastDigit = pBuffer[len-1];
    pBuffer[len-1] = '.';
    pBuffer[len] = lastDigit;
    pBuffer[len+1] = '\0';
}

const char* toString5 (char* pBuffer, const int a)
{
    snprintf(pBuffer, 16, "%.1f", a/10.0);
    return pBuffer;
}

const char* toString6 (char* pBuffer, const int a)
{
    snprintf(pBuffer, 16, "%d.%01d", a / 10, a % 10);
    return pBuffer;
}

string toString7 (const int a)
{
    ostringstream stream;
    stream << (a / 10) << '.' << (a % 10);
    return stream.str();
}

string toString8 (const int a)
{
    char buffer[16];
    string result = _itoa(a, buffer, 10);
    result.insert(result.length()-1, 1, '.'); 
    return result;
}

Basic benchmarks were run on the above methods for 100 million integers (starting from 0). If performance really matters for your case please profile/benchmark for yourself for your exact use-case.

• toString1 = 0.64 sec (itoa to string)
• toString1a = 0.61 sec (inplace, no return)
• toString2 = 33.4 sec (stringstream, ouch!)
• toString3 = 0.52 sec (itoa, static buffer)
• toString4 = 0.52 sec (itoa)
• toString4a = 0.52 sec (itoa, inplace)
• toString5 = 6.35 sec (snprintf, float)
• toString6 = 2.29 sec (snprintf, two ints)
• toString7 = 33.3 sec (stringstream, two ints)
• toString8 = 0.70 sec (itoa and string::insert)

Which one is "better" really depends on what you need. Personally I would use the simplest stream case (toString7) unless I was absolutely sure I needed the performance of the other methods.

Answer 4

#include <sstream>
#include <iostream>
#include <string>
using namespace std;

string toString(int a) {
    float f = a * 0.1f;
    ostringstream ss;
    ss << f;
    return ss.str();
}

int main() {
    cout << toString(101);
    return 0;
}

Answer 5

For c++11 you can use this:

std::string toString( int i )
{
    int t = abs( i );
    return ( i < 0 ? "-", "" ) + std::to_string( t / 10 ) + "." + std::to_string( t % 10 );
}

for pre c++11 you can replace it with std::stringstream or snprintf:

std::string toString( int i )
{
    char buffer[128] = { '-' };
    int t = abs( i );
    snprintf( buffer + 1, sizeof(buffer) - 1, "%d.%d", t / 10, t % 10 );
    return std::string( i < 0 ? buffer : buffer + 1 );
}

Answer 6

#include <sstream>
using namespace std;

string Decimal1ToString(int i)
{
    ostringstream stream;
    stream << (i / 10) << '.' << (i % 10);
    return stream.str();
}

Note the use of integer / and %. This prevents precision loss.

Answer 7

This is my version:

#include <iostream>

int main()
{
    char price[18];
    _itoa_s(98321, price, 10);
    int len = strlen(price);
    char lastDigit = price[len - 1];
    price[len - 1] = '.';
    price[len] = lastDigit;
    price[len + 1] = 0;

    printf(price);

    return 0;
}