Il faut utiliser les locales, plus particulièrement le facet numpunct :
class MyNumPunct : public std::numpunct<char>
{
protected:
virtual std::string do_grouping() const
{
return "3"; //groupes de 3 chiffres. Oui, le formattage de cetet
chaine est stupide.....
}
virtual char do_thousands_sep() const
{
return ' '; //séparés par espace
}
};
int main()
{
MyNumPunct* punct=new MyNumPunct(); //will be destroyed by the locale
destructor
//create a new locale based on cout, but using our specific numpunct
std::locale loc(std::cout.getloc (), punct);
std::cout.imbue (loc);
std::cout<<2123456789<<std::endl;
}
cf
http://www.roguewave.com/support/docs/leif/sourcepro/html/stdlibref/num-put.html
pour plus de détails.
Arnaud
MVP - VC
Il faut utiliser les locales, plus particulièrement le facet numpunct :
class MyNumPunct : public std::numpunct<char>
{
protected:
virtual std::string do_grouping() const
{
return "3"; //groupes de 3 chiffres. Oui, le formattage de cetet
chaine est stupide.....
}
virtual char do_thousands_sep() const
{
return ' '; //séparés par espace
}
};
int main()
{
MyNumPunct* punct=new MyNumPunct(); //will be destroyed by the locale
destructor
//create a new locale based on cout, but using our specific numpunct
std::locale loc(std::cout.getloc (), punct);
std::cout.imbue (loc);
std::cout<<2123456789<<std::endl;
}
cf
http://www.roguewave.com/support/docs/leif/sourcepro/html/stdlibref/num-put.html
pour plus de détails.
Arnaud
MVP - VC
Il faut utiliser les locales, plus particulièrement le facet numpunct :
class MyNumPunct : public std::numpunct<char>
{
protected:
virtual std::string do_grouping() const
{
return "3"; //groupes de 3 chiffres. Oui, le formattage de cetet
chaine est stupide.....
}
virtual char do_thousands_sep() const
{
return ' '; //séparés par espace
}
};
int main()
{
MyNumPunct* punct=new MyNumPunct(); //will be destroyed by the locale
destructor
//create a new locale based on cout, but using our specific numpunct
std::locale loc(std::cout.getloc (), punct);
std::cout.imbue (loc);
std::cout<<2123456789<<std::endl;
}
cf
http://www.roguewave.com/support/docs/leif/sourcepro/html/stdlibref/num-put.html
pour plus de détails.
Arnaud
MVP - VC
[...]
cout << "cout.imbue(locale::locale("fr_FR.UTF-8"))n";
cout.imbue(locale::locale("fr_FR.UTF-8"));
cout << pi_M << endl; //3 141,5926 -> OK
printf("printf : %.4fn", pi_M); //3141,5926 -> pas d'espace
return 0;
}
Voilà en choisissant tout simplement la bonne locale :P , pas sûr que
sous windows ça marche (mais je m'en moque). En C le mécanisme est
analogue d'après ce que j'ai lu.
Par contre j'imagine que si je veux grouper les décimales par trois il
va falloir que je dérive _mais je me sers de moins de 3 décimales pour
le moment.
[...]
cout << "cout.imbue(locale::locale("fr_FR.UTF-8"))n";
cout.imbue(locale::locale("fr_FR.UTF-8"));
cout << pi_M << endl; //3 141,5926 -> OK
printf("printf : %.4fn", pi_M); //3141,5926 -> pas d'espace
return 0;
}
Voilà en choisissant tout simplement la bonne locale :P , pas sûr que
sous windows ça marche (mais je m'en moque). En C le mécanisme est
analogue d'après ce que j'ai lu.
Par contre j'imagine que si je veux grouper les décimales par trois il
va falloir que je dérive _mais je me sers de moins de 3 décimales pour
le moment.
[...]
cout << "cout.imbue(locale::locale("fr_FR.UTF-8"))n";
cout.imbue(locale::locale("fr_FR.UTF-8"));
cout << pi_M << endl; //3 141,5926 -> OK
printf("printf : %.4fn", pi_M); //3141,5926 -> pas d'espace
return 0;
}
Voilà en choisissant tout simplement la bonne locale :P , pas sûr que
sous windows ça marche (mais je m'en moque). En C le mécanisme est
analogue d'après ce que j'ai lu.
Par contre j'imagine que si je veux grouper les décimales par trois il
va falloir que je dérive _mais je me sers de moins de 3 décimales pour
le moment.
Il serait intéressant de voir ce que cela donne pour l'Inde et le
Pakistan (malheureusement je ne connais pas les codes de langue et
de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
Par contre j'imagine que si je veux grouper les décimales par trois il
va falloir que je dérive _mais je me sers de moins de 3 décimales pour
le moment.
Dans mes recherches pour ma page sur l'écriture des nombres, je n'ai
rien trouvé à propos d'une éventuelle séparation des décimales. Par
défaut, je supposerais donc qu'il n'y en a pas (et que le comportement
que tu as constaté est donc correct).
Il serait intéressant de voir ce que cela donne pour l'Inde et le
Pakistan (malheureusement je ne connais pas les codes de langue et
de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
Par contre j'imagine que si je veux grouper les décimales par trois il
va falloir que je dérive _mais je me sers de moins de 3 décimales pour
le moment.
Dans mes recherches pour ma page sur l'écriture des nombres, je n'ai
rien trouvé à propos d'une éventuelle séparation des décimales. Par
défaut, je supposerais donc qu'il n'y en a pas (et que le comportement
que tu as constaté est donc correct).
Il serait intéressant de voir ce que cela donne pour l'Inde et le
Pakistan (malheureusement je ne connais pas les codes de langue et
de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
Par contre j'imagine que si je veux grouper les décimales par trois il
va falloir que je dérive _mais je me sers de moins de 3 décimales pour
le moment.
Dans mes recherches pour ma page sur l'écriture des nombres, je n'ai
rien trouvé à propos d'une éventuelle séparation des décimales. Par
défaut, je supposerais donc qu'il n'y en a pas (et que le comportement
que tu as constaté est donc correct).
[...]
cout << "cout.imbue(locale::locale("fr_FR.UTF-8"))n";
cout.imbue(locale::locale("fr_FR.UTF-8"));
cout << pi_M << endl; //3 141,5926 -> OK
printf("printf : %.4fn", pi_M); //3141,5926 -> pas d'espace
return 0;
}
Voilà en choisissant tout simplement la bonne locale :P ,
pas sûr que sous windows ça marche (mais je m'en moque). En
C le mécanisme est analogue d'après ce que j'ai lu.
Il serait intéressant de voir ce que cela donne pour l'Inde et
le Pakistan (malheureusement je ne connais pas les codes de
langue et de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
Par contre j'imagine que si je veux grouper les décimales
par trois il va falloir que je dérive _mais je me sers de
moins de 3 décimales pour le moment.
Dans mes recherches pour ma page sur l'écriture des nombres,
je n'ai rien trouvé à propos d'une éventuelle séparation des
décimales. Par défaut, je supposerais donc qu'il n'y en a pas
(et que le comportement que tu as constaté est donc correct).
[...]
cout << "cout.imbue(locale::locale("fr_FR.UTF-8"))n";
cout.imbue(locale::locale("fr_FR.UTF-8"));
cout << pi_M << endl; //3 141,5926 -> OK
printf("printf : %.4fn", pi_M); //3141,5926 -> pas d'espace
return 0;
}
Voilà en choisissant tout simplement la bonne locale :P ,
pas sûr que sous windows ça marche (mais je m'en moque). En
C le mécanisme est analogue d'après ce que j'ai lu.
Il serait intéressant de voir ce que cela donne pour l'Inde et
le Pakistan (malheureusement je ne connais pas les codes de
langue et de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
Par contre j'imagine que si je veux grouper les décimales
par trois il va falloir que je dérive _mais je me sers de
moins de 3 décimales pour le moment.
Dans mes recherches pour ma page sur l'écriture des nombres,
je n'ai rien trouvé à propos d'une éventuelle séparation des
décimales. Par défaut, je supposerais donc qu'il n'y en a pas
(et que le comportement que tu as constaté est donc correct).
[...]
cout << "cout.imbue(locale::locale("fr_FR.UTF-8"))n";
cout.imbue(locale::locale("fr_FR.UTF-8"));
cout << pi_M << endl; //3 141,5926 -> OK
printf("printf : %.4fn", pi_M); //3141,5926 -> pas d'espace
return 0;
}
Voilà en choisissant tout simplement la bonne locale :P ,
pas sûr que sous windows ça marche (mais je m'en moque). En
C le mécanisme est analogue d'après ce que j'ai lu.
Il serait intéressant de voir ce que cela donne pour l'Inde et
le Pakistan (malheureusement je ne connais pas les codes de
langue et de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
Par contre j'imagine que si je veux grouper les décimales
par trois il va falloir que je dérive _mais je me sers de
moins de 3 décimales pour le moment.
Dans mes recherches pour ma page sur l'écriture des nombres,
je n'ai rien trouvé à propos d'une éventuelle séparation des
décimales. Par défaut, je supposerais donc qu'il n'y en a pas
(et que le comportement que tu as constaté est donc correct).
Il serait intéressant de voir ce que cela donne pour l'Inde et
le Pakistan (malheureusement je ne connais pas les codes de
langue et de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
C'est prévu. Il faut simplement que do_grouping renvoie "32"
(et que do_thousands_sep renvoie ',', évidemment). La règle,
c'est que le dernier grouping se répète.
Plus intéressant, c'est le cas de l'arabe, où les chiffres
apparaissent avec le chiffre de poids faible d'abord, à
l'inverse des notres, du point de vue de la direction normale de
l'écriture.
Dans mes recherches pour ma page sur l'écriture des nombres,
je n'ai rien trouvé à propos d'une éventuelle séparation des
décimales. Par défaut, je supposerais donc qu'il n'y en a pas
(et que le comportement que tu as constaté est donc correct).
Je suppose par là qu'il veut dire : les chiffres derrière le
décimal.
En effet, la norme ne prévoit rien. Dans la pratique,
je crois que c'est assez arbitraire ; ça ne m'étonnerait pas,
par exemple, de voir une table de logrithmes où les chiffres
sont régroupés par cinq.
D'après mes souvenirs, Plauger a dit
une fois que son implémentation (donc, celle de VC++) a une
extension pour le supporter, mais je n'en sais pas plus (et
l'extension n'est peut-être présente que dans les versions
étendues de la bibliothèque qu'il vend directement).
Il serait intéressant de voir ce que cela donne pour l'Inde et
le Pakistan (malheureusement je ne connais pas les codes de
langue et de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
C'est prévu. Il faut simplement que do_grouping renvoie "32"
(et que do_thousands_sep renvoie ',', évidemment). La règle,
c'est que le dernier grouping se répète.
Plus intéressant, c'est le cas de l'arabe, où les chiffres
apparaissent avec le chiffre de poids faible d'abord, à
l'inverse des notres, du point de vue de la direction normale de
l'écriture.
Dans mes recherches pour ma page sur l'écriture des nombres,
je n'ai rien trouvé à propos d'une éventuelle séparation des
décimales. Par défaut, je supposerais donc qu'il n'y en a pas
(et que le comportement que tu as constaté est donc correct).
Je suppose par là qu'il veut dire : les chiffres derrière le
décimal.
En effet, la norme ne prévoit rien. Dans la pratique,
je crois que c'est assez arbitraire ; ça ne m'étonnerait pas,
par exemple, de voir une table de logrithmes où les chiffres
sont régroupés par cinq.
D'après mes souvenirs, Plauger a dit
une fois que son implémentation (donc, celle de VC++) a une
extension pour le supporter, mais je n'en sais pas plus (et
l'extension n'est peut-être présente que dans les versions
étendues de la bibliothèque qu'il vend directement).
Il serait intéressant de voir ce que cela donne pour l'Inde et
le Pakistan (malheureusement je ne connais pas les codes de
langue et de pays).
<cit. http://www.miakinen.net/vrac/nombres#chiffres>
Dans quelques pays (Inde et Pakistan), les chiffres sont séparés
par paires, sauf les 3 premiers (10,00,000 = 1 000 000) [quid].
</>
C'est prévu. Il faut simplement que do_grouping renvoie "32"
(et que do_thousands_sep renvoie ',', évidemment). La règle,
c'est que le dernier grouping se répète.
Plus intéressant, c'est le cas de l'arabe, où les chiffres
apparaissent avec le chiffre de poids faible d'abord, à
l'inverse des notres, du point de vue de la direction normale de
l'écriture.
Dans mes recherches pour ma page sur l'écriture des nombres,
je n'ai rien trouvé à propos d'une éventuelle séparation des
décimales. Par défaut, je supposerais donc qu'il n'y en a pas
(et que le comportement que tu as constaté est donc correct).
Je suppose par là qu'il veut dire : les chiffres derrière le
décimal.
En effet, la norme ne prévoit rien. Dans la pratique,
je crois que c'est assez arbitraire ; ça ne m'étonnerait pas,
par exemple, de voir une table de logrithmes où les chiffres
sont régroupés par cinq.
D'après mes souvenirs, Plauger a dit
une fois que son implémentation (donc, celle de VC++) a une
extension pour le supporter, mais je n'en sais pas plus (et
l'extension n'est peut-être présente que dans les versions
étendues de la bibliothèque qu'il vend directement).
Ah? J'ai pourtant testé mon exemple avec Visual 2005 sans problèmes ;-)
Ah? J'ai pourtant testé mon exemple avec Visual 2005 sans problèmes ;-)
Ah? J'ai pourtant testé mon exemple avec Visual 2005 sans problèmes ;-)
Non plus. Pourquoi toutes ces manipulations numériques ?
il fait beaucoup de calculs supplémentaires pour rien.
[............] Mais rien ne dit que snprintf n'appelle pas
std::ostringstream.
char buffer[ sizeof( long ) * CHAR_BIT ] ;
sprintf( buffer, "%d", value ) ;
Ensuite, on insère les espaces où voulu.
On a déjà compris ici. Tu n'as pas envie d'apprendre de
nouvelles techniques. Quoiqu'elles puissent apporter.
Non plus. Pourquoi toutes ces manipulations numériques ?
il fait beaucoup de calculs supplémentaires pour rien.
[............] Mais rien ne dit que snprintf n'appelle pas
std::ostringstream.
char buffer[ sizeof( long ) * CHAR_BIT ] ;
sprintf( buffer, "%d", value ) ;
Ensuite, on insère les espaces où voulu.
On a déjà compris ici. Tu n'as pas envie d'apprendre de
nouvelles techniques. Quoiqu'elles puissent apporter.
Non plus. Pourquoi toutes ces manipulations numériques ?
il fait beaucoup de calculs supplémentaires pour rien.
[............] Mais rien ne dit que snprintf n'appelle pas
std::ostringstream.
char buffer[ sizeof( long ) * CHAR_BIT ] ;
sprintf( buffer, "%d", value ) ;
Ensuite, on insère les espaces où voulu.
On a déjà compris ici. Tu n'as pas envie d'apprendre de
nouvelles techniques. Quoiqu'elles puissent apporter.
sprintf( buffer, "%d", value ) ;
Ensuite, on insère les espaces où voulu.
en couteuse recopie ? pas terrible comme solution.
sprintf( buffer, "%d", value ) ;
Ensuite, on insère les espaces où voulu.
en couteuse recopie ? pas terrible comme solution.
sprintf( buffer, "%d", value ) ;
Ensuite, on insère les espaces où voulu.
en couteuse recopie ? pas terrible comme solution.
Coûteuse en temps d'exécution, par rapport aux log10(), pow(),
sprintf() multiples
diverses multiplications et divisions
(non remplaçables par des simples décalages...) ?
Autre question : Qu'est-ce qui nous garantit que log10(1000)
ne donne pas par exemple 2.99999999999999956 sur certains systèmes
- valeur qui sera arrondie à 2 lors de la conversion en int ?
Coûteuse en temps d'exécution, par rapport aux log10(), pow(),
sprintf() multiples
diverses multiplications et divisions
(non remplaçables par des simples décalages...) ?
Autre question : Qu'est-ce qui nous garantit que log10(1000)
ne donne pas par exemple 2.99999999999999956 sur certains systèmes
- valeur qui sera arrondie à 2 lors de la conversion en int ?
Coûteuse en temps d'exécution, par rapport aux log10(), pow(),
sprintf() multiples
diverses multiplications et divisions
(non remplaçables par des simples décalages...) ?
Autre question : Qu'est-ce qui nous garantit que log10(1000)
ne donne pas par exemple 2.99999999999999956 sur certains systèmes
- valeur qui sera arrondie à 2 lors de la conversion en int ?
Arnaud Debaene wrote on 06/07/2006 08:13:
et tu l'as testé avec les include idoines, comme mon vocabulaire de base
se limite à stdio.h et string.h, ça ne pouvoit pas compiler tout seul -
c'est peut être une idée utile d'indiquer ses incl, non ?
Arnaud Debaene wrote on 06/07/2006 08:13:
et tu l'as testé avec les include idoines, comme mon vocabulaire de base
se limite à stdio.h et string.h, ça ne pouvoit pas compiler tout seul -
c'est peut être une idée utile d'indiquer ses incl, non ?
Arnaud Debaene wrote on 06/07/2006 08:13:
et tu l'as testé avec les include idoines, comme mon vocabulaire de base
se limite à stdio.h et string.h, ça ne pouvoit pas compiler tout seul -
c'est peut être une idée utile d'indiquer ses incl, non ?
