c ++: Nummer mit Kommas formatieren?

Ich möchte eine Methode schreiben, die eine Ganzzahl verwendet und eine std::stringdieser mit Kommas formatierten Ganzzahlen zurückgibt.

Beispieldeklaration:

std::string FormatWithCommas(long value);

Anwendungsbeispiel:

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

Wie formatiert C ++ eine Zahl als stringKomma?

(Bonus wäre, auch mit doubles umzugehen.)

Verwenden Sie std::localemitstd::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();
}

Haftungsausschluss: Portabilität kann ein Problem sein, und Sie sollten sich wahrscheinlich ansehen, welches Gebietsschema verwendet wird, wenn ""es übergeben wird

Sie können tun, was Jacob vorgeschlagen hat, und zwar imbuemit dem ""Gebietsschema - dies verwendet jedoch die Systemvorgabe, die nicht garantiert, dass Sie das Komma erhalten. Wenn Sie das Komma erzwingen möchten (unabhängig von den Standardeinstellungen des Systems), können Sie dies tun, indem Sie Ihre eigene numpunctFacette angeben. Zum Beispiel:

#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;
}

Ich halte die folgende Antwort für einfacher als die anderen:

#include <iostream>
int main() {
   auto s = std::to_string(7654321);
   int n = s.length() - 3;
   while (n > 0) {
      s.insert(n, ",");
      n -= 3;
   }
   std::cout << (s == "7,654,321") << std::endl;
}   

Dadurch werden schnell und korrekt Kommas in Ihre Ziffernfolge eingefügt.

Dies ist eine ziemlich alte Schule. Ich verwende sie in großen Schleifen, um zu vermeiden, dass ein weiterer Zeichenfolgenpuffer instanziiert wird.

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)?"":",");
    }
}

Basierend auf den obigen Antworten kam ich zu folgendem 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();
}

Wenn Sie Qt verwenden, können Sie diesen Code verwenden:

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

Vergessen Sie auch nicht, hinzuzufügen #include <QLocale>.

Um es flexibler zu machen, können Sie die Facette mit einer benutzerdefinierten Zeichenfolge für Tausende und Gruppen erstellen. Auf diese Weise können Sie es zur Laufzeit einstellen.

#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;
}