Format number with commas in C++

I want to write a method that will take an integer and return a std::string of that integer formatted with commas.

Example declaration:

std::string FormatWithCommas(long value);

Example usage:

std::string result1 = FormatWithCommas(7800);
std::string result2 = FormatWithCommas(5100100);
std::string result3 = FormatWithCommas(201234567890);
// result1 = "7,800"
// result2 = "5,100,100"
// result3 = "201,234,567,890"

What is the C++ way of formatting a number as a string with commas?

(Bonus would be to handle doubles as well.)

92858 次浏览
小开
最佳答案

Use std::locale with std::stringstream

#include <iomanip>
#include <locale>


template<class T>
std::string FormatWithCommas(T value)
{
std::stringstream ss;
ss.imbue(std::locale(""));
ss << std::fixed << value;
return ss.str();
}

Disclaimer: Portability might be an issue and you should probably look at which locale is used when "" is passed

小开

You can do as Jacob suggested, and imbue with the "" locale - but this will use the system default, which does not guarantee that you get the comma. If you want to force the comma (regardless of the systems default locale settings) you can do so by providing your own numpunct facet. For example:

#include <locale>
#include <iostream>
#include <iomanip>


class comma_numpunct : public std::numpunct<char>
{
protected:
virtual char do_thousands_sep() const
{
return ',';
}


virtual std::string do_grouping() const
{
return "\03";
}
};


int main()
{
// this creates a new locale based on the current application default
// (which is either the one given on startup, but can be overriden with
// std::locale::global) - then extends it with an extra facet that
// controls numeric output.
std::locale comma_locale(std::locale(), new comma_numpunct());


// tell cout to use our new locale.
std::cout.imbue(comma_locale);


std::cout << std::setprecision(2) << std::fixed << 1000000.1234;
}
小开

based on the answers above, I ended up with this code:

#include <iomanip>
#include <locale>


template<class T>
std::string numberFormatWithCommas(T value){
struct Numpunct: public std::numpunct<char>{
protected:
virtual char do_thousands_sep() const{return ',';}
virtual std::string do_grouping() const{return "\03";}
};
std::stringstream ss;
ss.imbue({std::locale(), new Numpunct});
ss << std::setprecision(2) << std::fixed << value;
return ss.str();
}
小开

I consider the following answer to be easier than the others:

#include <iostream>
int main() {
int v = 7654321;
auto s = std::to_string(v);


int n = s.length() - 3;
int end = (v >= 0) ? 0 : 1; // Support for negative numbers
while (n > end) {
s.insert(n, ",");
n -= 3;
}
std::cout << (s == "7,654,321") << std::endl;
}

This will quickly and correctly insert commas into your string of digits.

小开

To make it more flexible, you could construct the facet with a custom thousands sep and grouping string. This way you can set it at runtime.

#include <locale>
#include <iostream>
#include <iomanip>
#include <string>


class comma_numpunct : public std::numpunct<char>
{
public:
comma_numpunct(char thousands_sep, const char* grouping)
:m_thousands_sep(thousands_sep),
m_grouping(grouping){}
protected:
char do_thousands_sep() const{return m_thousands_sep;}
std::string do_grouping() const {return m_grouping;}
private:
char m_thousands_sep;
std::string m_grouping;
};


int main()
{


std::locale comma_locale(std::locale(), new comma_numpunct(',', "\03"));


std::cout.imbue(comma_locale);
std::cout << std::setprecision(2) << std::fixed << 1000000.1234;
}
小开

If you are using Qt, you can use this code:

const QLocale& cLocale = QLocale::c();
QString resultString = cLocale.toString(number);

Also, do not forget to add #include <QLocale>.

小开

This is pretty old school, I use it in large loops to avoid instantiating another string buffer.

void tocout(long a)
{
long c = 1;


if(a<0) {a*=-1;cout<<"-";}
while((c*=1000)<a);
while(c>1)
{
int t = (a%c)/(c/1000);
cout << (((c>a)||(t>99))?"":((t>9)?"0":"00")) << t;
cout << (((c/=1000)==1)?"":",");
}
}
小开

Make another solution:

#include <stdio.h>
#include <string>
#include <stdint.h>
#include <inttypes.h>


std::string GetReadableNum(uint64_t n)
{
std::string strRet;
char szTmp[256] = { 0 };
int ccWritten = sprintf(szTmp, "%" PRIu64 "", n);
if (ccWritten > 0)
{
int nGroup = (ccWritten + 2) / 3;
int nReminder = ccWritten % 3;
        

strRet.reserve(ccWritten + (nGroup -1) * 3 + 1);
const char* p = szTmp;
for (int i = 0; i < nGroup; i++)
{
if (nGroup > 1 && i > 0)
strRet.append(1, ',');


for (int c = 0; c < (i > 0 || nReminder == 0 ? 3 : nReminder); c++)
strRet.append(1, *p++);
}
}


return strRet;
}


int main(int argc, const char* argv[])
{
uint64_t a = 123456789123ULL;


std::string s = GetReadableNum(a);


printf("%s\n", s.c_str());


return 0;
}
小开

I found the solution! just copy this to one of your function, this function is written in static function.

// Convert 100000000 to 100,000,000, put commas on the numbers!


std::string AppManager::convertNumberToString(int number) {
std::string s = std::to_string(number);
std::string result = "";
std::string tempResult = "";
unsigned long n = s.length() - 3;
int j = 0;
for (int i=s.size()-1; i>=0; i--) {
if (j%3 == 0) {
result.append(",");
}
result.append(s, i, 1);
j++;
}
    

result = result.substr(1, result.size()-1);
    

//now revert back
for (int i=result.size()-1; i>=0; i--) {
tempResult.append(result, i, 1);
}
    

return tempResult;
}

Here is the result of those code:

click here for seeing the result above!

小开

I have seen so many ways of doing this, reversing the string(Twice!), using setlocale(sometimes works sometimes not) This is a template solution, I then add explicit specializations. This works for char*, wchar*, string and wstring. I dont translate from numeric to string format here, I highly recommend to_string and to_wstring they are way faster than the 'C' functions such as _itoa etc...

    template<typename T, typename U>
T StrFormatNumber(const T Data) {
const size_t Length = Data.length();
assert(Length > 0);
// if( 0 == Length ) I would log this and return
if (Length < 4) { // nothing to do just return
return Data;
}
constexpr size_t buf_size{ 256 };
assert(((Length)+(Length / 3)) + 1 < buf_size);
if (((Length)+(Length / 3)) + 1 >= buf_size) {
throw std::invalid_argument( "Input buffer too large" );
}
std::array<U, buf_size > temp_buf{};
auto p{ 0 };
temp_buf[0] = Data[0];
for (auto y{ 1 }; y < Length; y++) {
if ((Length - y) % 3 == 0) {
temp_buf[y + p] = ',';
p++;
}
temp_buf[(y + p)] = Data[y];
}
return temp_buf.data();
}
template<typename T = const char*>
std::string StrFormatNum(const char* Data) {
return StrFormatNumber<std::string, char>(std::string(Data));
}
template<typename T= std::string>
std::string StrFormatNum(const std::string Data) {
return StrFormatNumber<std::string, char>(Data);
}
template<typename T = std::wstring>
std::wstring StrFormatNum( const std::wstring Data) {
return StrFormatNumber<std::wstring, wchar_t>(Data);
}
template<typename T = const wchar_t*>
std::wstring StrFormatNum( const wchar_t* Data) {
return StrFormatNumber<std::wstring, wchar_t>(std::wstring(Data));
}


void TestStrFormatNumber() {
constexpr auto Iterations{ 180 };
for (auto l{ 0 }; l < Iterations; l++)
{
{  // std::string
std::string mystr{ "10" };
for (int y{ 0 }; y < Iterations; y++) {


mystr += "1";
auto p = mystr.length();
std::cout << "\r\n  mystr      = "
<< std::setw(80) << mystr.c_str()
<< "\r\n  Length     = "
<< std::setw(10) << p
<< "\r\n  modulo % 3 = "
<< std::setw(10)
<< p % 3 << "     divided by 3 = "
<< std::setw(10) << p / 3
<< "\r\n  Formatted  = " <<
StrFormatNum((mystr)).c_str() << "\n";
}
}
{  // std::wstring
std::wstring mystr{ L"10" };
for (int y{ 0 }; y < Iterations; y++)
{
mystr += L"2";
auto p = mystr.length();
std::wcout << "\r\n  mystr      = "
<< std::setw(80) << mystr.c_str()
<< "\r\n  Length     = "
<< std::setw(10) << p
<< "\r\n  modulo % 3 = "
<< std::setw(10) << p % 3
<< "     divided by 3 = "
<< std::setw(10) << p / 3
<< "\r\n  Formatted  = "
<< StrFormatNum((mystr)).c_str()
<< "\n";
}
}
{   // char*
std::string mystr{ "10" };
for (int y{ 0 }; y < Iterations; y++) {
mystr += "3";
auto p = mystr.length();
std::cout << "\r\n  mystr      = " << std::setw(80) << mystr.c_str()
<< "\r\n    Length     = " << std::setw(10) << p
<< "\r\n  modulo % 3 = " << std::setw(10) << p % 3 << "     divided by 3 = " << std::setw(10) << p / 3
<< "\r\n  Formatted  = " << StrFormatNum((mystr.c_str())).c_str() << "\n";
}
}
{  // wchar*
std::wstring mystr{ L"10" };
for (int y{ 0 }; y < Iterations; y++) {
mystr += L"4";
auto p = mystr.length();
std::wcout << "\r\n  mystr      = " << std::setw(80) << mystr.c_str()
<< "\r\n  Length     = " << std::setw(10) << p
<< "\r\n  modulo % 3 = " << std::setw(10) << p % 3 << "     divided by 3 = " << std::setw(10) << p / 3
<< "\r\n  Formatted  = " << StrFormatNum((mystr.c_str())).c_str() << "\n";
}
}
}

}

I have tested up to 1,000 spaces(With a larger buffer of course)

小开

I like to keep my methods simple and modular for universal use. You asked for a method that will format an integer for output. This is my method to format a number for output with options to get integer value, set precision (Mostly if your formatting for money), and even return a numbers full double precision value. This works on Unix, Linux, and Windows operating systems. Most important you do not need to #include any specialized libraries.

#include <iostream>
#include <string>


// Format Number
static std::string FormatNumberForOutput(double number)
{
std::string format;
char decimal = '.', comma = ',';


format = std::to_string(number);// Will add decimal


if (format.find(decimal) > 3)
{
format.insert(format.find(decimal) - 3, 1, comma);
}
if (format.find(decimal) > 7)
{
while (format.find(comma) > 3)
{
format.insert(format.find(comma) - 3, 1, comma);
}
}


//modify format.find(decimal) + x to change precision
//return format.substr(0, format.find(decimal) + 3);//sets precision of 2
//return format;//for full precision of double


return format.substr(0, format.find(decimal));//returns integer


}//end FormatNumberForOutput()










int main()
{
int number = 42, bigger_number = 4200000;
    

// This proves that implicit conversion works perfectly
// without the need for an explicit cast. Any number can
// be promoted to type double without data loss.
    

// You can throw any number type at this method and always
// yield reliable results.
std::cout << FormatNumberForOutput(number) << std::endl;// 42
std::cout << FormatNumberForOutput(bigger_number) << std::endl;// 4,200,000
return 0;
}
小开

Based on Jacob's answer above...

This is a Windows solution.

// Compiler : Visual Studio 2022
// I tested on Windows 10 64bit
// DATE: 2022.Sep.15


#include <windows.h>
#include <string>
#include <locale>
#include <sstream>


using namespace std;


template<class T>
std::string FormatWithCommas(T value)
{
std::stringstream ss;


// otherwise, use "en_US.UTF-8" as the locale name
ss.imbue(std::locale("ko_KR.UTF-8"));
ss << std::fixed << value;


return ss.str();
}


int main()
{
LARGE_INTEGER filesize;


filesize.QuadPart = 1234591046976109;


// This only works for ASCII strings
string aaa = (FormatWithCommas(filesize.QuadPart)).c_str();
std::wstring widestr = std::wstring(aaa.begin(), aaa.end());
const wchar_t* widecstr = widestr.c_str();


wprintf_s(L"\nFile Size =  %s bytes\n", widecstr);


getchar();
return 0;
}

The execution result is as follows.

The execution result is as follows.

小开

Inspired by @carljalal's answer, I found a similar-but-different answer using reverse iterators. Probably less efficient, but a bit more compact:

#include <string>
#include <iterator>
#include <cctype>  // for isdigit
...


void addCommas(std::string& num)
{
// begin at the 3rd digit from the back, advance 3 each time
for (auto it = str.rbegin()+3; it < str.rend(); it += 3)
{
// this handles a negative sign (ignores it)
if (isdigit(*it))
{
// there are currently no string functions dealing with reverse_iterators,
// so use .base() to get it's corresponding forward_iterator


// inserting into a string invalidates any iterators, so "reset" `it`, and
// we have to make the return value into a reverse_iterator
it = std::make_reverse_iterator(str.insert(it.base(), ','));
}
}
}

Note, there is some wariness using .base(), but all seems to be well for the inputs I tried. Above handles any length number string, with or without a preceding negative sign, but does not handle decimals. Also note that std::make_reverse_iterator requires c++14 or later.

Some sample inputs and outputs:

1 ==>                  1
12 ==>                 12
123 ==>                123
-12 ==>               -12
-123 ==>              -123
1234 ==>               1,234
-1234 ==>             -1,234
12134 ==>              12,134
-12134 ==>            -12,134
328947328949893 ==>    328,947,328,949,893
-328947328949893 ==>  -328,947,328,949,893
9328947328949893 ==>   9,328,947,328,949,893
-9328947328949893 ==> -9,328,947,328,949,893

Demonstration


提交答案