ich bin neu hier im forum, vom fachwissen her anfänger und suche rat für folgende problemstellung:

double a = 9999999.99

wie bekomme ich es hin, dass zwischen den hundertern und tausendern, usw. je ein leerzeichen eingefügt wird so dass es dann so aussieht:

9 999 999.99

ich wäre sehr dankbar wenn ihr mir weiterhelfen könntet.

Deutsche Tausendertrennzeichen sind Punkte.

#include <iostream>
#include <locale>
using namespace std;

int main ()
{
   locale myloc (locale("de_DE"), new numpunct_byname<char>("fr_FR")); //oder wie auch immer die locales heißen
   cout.imbue(myloc);
   cout << 1234.56 << endl;
}

oder zur sicherheit:

#include <iostream>
#include <locale>
using namespace std;

class user_numpunct : public numpunct_byname<char>
{
public:
   user_numpunct (char const* name= "de_DE")
   : numpunct_byname<char>(name) {}

protected:
   char do_thousands_sep () const { return ' '; }
};

int main ()
{
   locale myloc (locale("de_DE"), new user_numpunct);
   cout.imbue(myloc);
   cout << 123456789 << endl;
}

IIRC.

Mit Datentyp double kriegste das gar nicht hin, ...

mal wieder ein völlige Unterschätzung der Möglichkeiten der IO-Library von C++. So geht's:

#include <iostream>
#include <iomanip>  // setprecision
#include <string>
#include <locale>   // numpunct<>

class MyNumPut : public std::numpunct< char >
{
protected:
    std::string do_grouping() const
    {
        return std::string( 1, char(3) ); // 1 x \003 := dreier Gruppen
    }
    char_type do_thousands_sep() const
    {
        return ' '; // Space als Tausendertrenner
    }
};

int main()
{
    using namespace std;
    cout.imbue( locale( cout.getloc(), new MyNumPut ) );
    double d = 9999999.99;
    cout << setprecision(9); // damit auch 9 9'ner erscheinen
    cout << d << endl;
    return 0;
}

Gruß
Werner

was du machst ist einfach nur eine speille ausgabe des wertes - hat mit double an der stelle nix zu tun keonnte in dem fall auch ein int sein usw

über die ausgabe printf kann man das nicht realisieren?

über die ausgabe printf kann man das nicht realisieren?

Nicht portabel. Was spricht gegen C++ Streams?

das problem ist, dass der wert von a in einer berechnung ermittelt wird und unterschiedliche werte annehmen kann.

Wieso ist das ein Problem?

Hast du den Code von Werner Salomon oder queer_boy mal ausprobiert?

P.T. schrieb:

das problem ist, dass der wert von a in einer berechnung ermittelt wird und unterschiedliche werte annehmen kann.

Wieso ist das ein Problem?

vielleicht deshalb, weil es unsauber aussieht, wenn man die unterschiedlich großen Zahlen einfach so untereinander ausgibt.
Der Manipulator 'setw()' schafft hier Abhilfe. Folgender Code:

#include <iostream>
#include <iomanip>  // setprecision, setw
#include <string>
#include <locale>   // numpunct<>

class MyNumPut : public std::numpunct< char >
{
protected:
    std::string do_grouping() const
    {
        return std::string( 1, char(3) ); // 1 x \003 := dreier Gruppen
    }
    char_type do_thousands_sep() const
    {
        return ' '; // Space als Tausendertrenner
    }
};

int main()
{
    using namespace std;
    cout.imbue( locale( cout.getloc(), new MyNumPut ) );
    cout << fixed << setprecision(2); // immer 2 Nachkommastellen
    for( double d = 1.73466; d < 10000000.; d *= 7 )
        cout << setw(15) << d << endl;
    return 0;
}

erzeugt diese Ausgabe

1.73
          12.14
          85.00
         594.99
       4 164.92
      29 154.43
     204 081.01
   1 428 567.10
   9 999 969.70

Gruß
Werner