Wie kann ich im C-Format eine Zahl von 1123456789
bis formatieren 1,123,456,789
? Ich habe es versucht, printf("%'10d\n", 1123456789);
aber das funktioniert nicht.
Könnten Sie etwas raten? Je einfacher die Lösung, desto besser.
Wie kann ich im C-Format eine Zahl von 1123456789
bis formatieren 1,123,456,789
? Ich habe es versucht, printf("%'10d\n", 1123456789);
aber das funktioniert nicht.
Könnten Sie etwas raten? Je einfacher die Lösung, desto besser.
LC_NUMERIC
. Ich weiß jedoch nicht, welches Gebietsschema dies unterstützt.
LC_NUMERIC
locale auf den aktuellen ""
macht die '
Arbeit auf meinem Mac und auf einer Linux - Maschine , die ich gerade überprüft.
printf()
Funktionsfamilie die Verwendung des '
Zeichens (einfaches Anführungszeichen oder Apostroph) mit den Konvertierungsspezifikationen für die Dezimalzahlformatierung standardisieren, um anzugeben, dass die Zahl mit Tausenden von Trennzeichen formatiert werden soll.
"C"
das nicht monetäre Tausendertrennzeichen undefiniert ist, sodass "%'d"
im "C"
Gebietsschema keine Kommas erzeugt werden . Sie müssen ein Gebietsschema mit einem geeigneten nicht monetären Tausendertrennzeichen festlegen. setlocale(LC_ALL, "");
Wird oft die Arbeit erledigen - andere Werte für den Gebietsschemanamen (außer der leeren Zeichenfolge) sind implementierungsdefiniert.
Antworten:
Wenn Ihr printf das '
Flag unterstützt (wie von POSIX 2008 gefordert printf()
), können Sie dies wahrscheinlich tun, indem Sie Ihr Gebietsschema entsprechend festlegen. Beispiel:
#include <stdio.h>
#include <locale.h>
int main(void)
{
setlocale(LC_NUMERIC, "");
printf("%'d\n", 1123456789);
return 0;
}
Und bauen & laufen lassen:
$ ./example
1,123,456,789
Getestet unter Mac OS X & Linux (Ubuntu 10.10).
sprintf()
in einem eingebetteten System getestet und es funktioniert nicht (offensichtlich, weil es, wie Sie sagen, die Flagge nicht unterstützt.
'
. Aus dem Header: Copyright ... 2007 Joerg Wunsch ... 1993 Regents of the University of California
dh eine BSD-Ableitung.
Sie können dies rekursiv wie folgt tun (Vorsicht, INT_MIN
wenn Sie das Zweierkomplement verwenden, benötigen Sie zusätzlichen Code, um dies zu verwalten):
void printfcomma2 (int n) {
if (n < 1000) {
printf ("%d", n);
return;
}
printfcomma2 (n/1000);
printf (",%03d", n%1000);
}
void printfcomma (int n) {
if (n < 0) {
printf ("-");
n = -n;
}
printfcomma2 (n);
}
Eine Zusammenfassung:
printfcomma
mit einer Ganzzahl, der Sonderfall negativer Zahlen wird behandelt, indem einfach "-" gedruckt und die Zahl positiv gemacht wird (dies ist das Bit, mit dem nicht funktioniert INT_MIN
).printfcomma2
, wird eine Zahl unter 1.000 nur gedruckt und zurückgegeben.Es gibt auch die prägnantere Version, obwohl sie auf jeder Ebene unnötig nach negativen Zahlen sucht (nicht, dass dies angesichts der begrenzten Anzahl von Rekursionsstufen von Bedeutung ist). Dies ist ein vollständiges Programm zum Testen:
#include <stdio.h>
void printfcomma (int n) {
if (n < 0) {
printf ("-");
printfcomma (-n);
return;
}
if (n < 1000) {
printf ("%d", n);
return;
}
printfcomma (n/1000);
printf (",%03d", n%1000);
}
int main (void) {
int x[] = {-1234567890, -123456, -12345, -1000, -999, -1,
0, 1, 999, 1000, 12345, 123456, 1234567890};
int *px = x;
while (px != &(x[sizeof(x)/sizeof(*x)])) {
printf ("%-15d: ", *px);
printfcomma (*px);
printf ("\n");
px++;
}
return 0;
}
und die Ausgabe ist:
-1234567890 : -1,234,567,890
-123456 : -123,456
-12345 : -12,345
-1000 : -1,000
-999 : -999
-1 : -1
0 : 0
1 : 1
999 : 999
1000 : 1,000
12345 : 12,345
123456 : 123,456
1234567890 : 1,234,567,890
Eine iterative Lösung für diejenigen, die der Rekursion nicht vertrauen (obwohl das einzige Problem bei der Rekursion in der Regel der Stapelspeicher ist, der hier kein Problem darstellt, da er selbst für eine 64-Bit-Ganzzahl nur wenige Ebenen tief ist):
void printfcomma (int n) {
int n2 = 0;
int scale = 1;
if (n < 0) {
printf ("-");
n = -n;
}
while (n >= 1000) {
n2 = n2 + scale * (n % 1000);
n /= 1000;
scale *= 1000;
}
printf ("%d", n);
while (scale != 1) {
scale /= 1000;
n = n2 / scale;
n2 = n2 % scale;
printf (",%03d", n);
}
}
Beide erzeugen 2,147,483,647
für INT_MAX
.
n
in printfcomma
. Sie müssen eine Konvertierung in unsigned erzwingen, bevor Sie sie negieren.
printf
.
Hier ist eine sehr einfache Implementierung. Diese Funktion enthält keine Fehlerprüfung, Puffergrößen müssen vom Aufrufer überprüft werden. Es funktioniert auch nicht für negative Zahlen. Solche Verbesserungen bleiben dem Leser als Übung überlassen.
void format_commas(int n, char *out)
{
int c;
char buf[20];
char *p;
sprintf(buf, "%d", n);
c = 2 - strlen(buf) % 3;
for (p = buf; *p != 0; p++) {
*out++ = *p;
if (c == 1) {
*out++ = ',';
}
c = (c + 1) % 3;
}
*--out = 0;
}
Egads! Ich mache das die ganze Zeit mit gcc / g ++ und glibc unter Linux und ja, der Operator 'ist vielleicht nicht Standard, aber ich mag die Einfachheit.
#include <stdio.h>
#include <locale.h>
int main()
{
int bignum=12345678;
setlocale(LC_ALL,"");
printf("Big number: %'d\n",bignum);
return 0;
}
Gibt Ausgabe von:
Große Zahl: 12.345.678
Sie müssen sich nur an den 'setlocale'-Aufruf erinnern, sonst wird nichts formatiert.
'
Flag nicht unterstützt , Sie nicht die gewünschte Ausgabe erhalten - und das unabhängig vom Compiler. Der Compiler stellt sicher, dass die Bibliotheksfunktion für printf()
mit der Formatzeichenfolge aufgerufen wird. Es liegt an der Bibliotheksfunktion, sie zu interpretieren. Unter Windows ist es durchaus möglich, dass die CRT-Bibliothek nicht die Unterstützung bietet, die Sie benötigen - und es spielt keine Rolle, welchen Compiler Sie verwenden.
Vielleicht wäre eine länderbezogene Version interessant.
#include <stdlib.h>
#include <locale.h>
#include <string.h>
#include <limits.h>
static int next_group(char const **grouping) {
if ((*grouping)[1] == CHAR_MAX)
return 0;
if ((*grouping)[1] != '\0')
++*grouping;
return **grouping;
}
size_t commafmt(char *buf, /* Buffer for formatted string */
int bufsize, /* Size of buffer */
long N) /* Number to convert */
{
int i;
int len = 1;
int posn = 1;
int sign = 1;
char *ptr = buf + bufsize - 1;
struct lconv *fmt_info = localeconv();
char const *tsep = fmt_info->thousands_sep;
char const *group = fmt_info->grouping;
char const *neg = fmt_info->negative_sign;
size_t sep_len = strlen(tsep);
size_t group_len = strlen(group);
size_t neg_len = strlen(neg);
int places = (int)*group;
if (bufsize < 2)
{
ABORT:
*buf = '\0';
return 0;
}
*ptr-- = '\0';
--bufsize;
if (N < 0L)
{
sign = -1;
N = -N;
}
for ( ; len <= bufsize; ++len, ++posn)
{
*ptr-- = (char)((N % 10L) + '0');
if (0L == (N /= 10L))
break;
if (places && (0 == (posn % places)))
{
places = next_group(&group);
for (int i=sep_len; i>0; i--) {
*ptr-- = tsep[i-1];
if (++len >= bufsize)
goto ABORT;
}
}
if (len >= bufsize)
goto ABORT;
}
if (sign < 0)
{
if (len >= bufsize)
goto ABORT;
for (int i=neg_len; i>0; i--) {
*ptr-- = neg[i-1];
if (++len >= bufsize)
goto ABORT;
}
}
memmove(buf, ++ptr, len + 1);
return (size_t)len;
}
#ifdef TEST
#include <stdio.h>
#define elements(x) (sizeof(x)/sizeof(x[0]))
void show(long i) {
char buffer[32];
commafmt(buffer, sizeof(buffer), i);
printf("%s\n", buffer);
commafmt(buffer, sizeof(buffer), -i);
printf("%s\n", buffer);
}
int main() {
long inputs[] = {1, 12, 123, 1234, 12345, 123456, 1234567, 12345678 };
for (int i=0; i<elements(inputs); i++) {
setlocale(LC_ALL, "");
show(inputs[i]);
}
return 0;
}
#endif
Dies hat einen Fehler (aber einen, den ich als ziemlich geringfügig betrachten würde). Auf der Zweierkomplement-Hardware wird die negativste Zahl nicht korrekt konvertiert, da versucht wird, eine negative Zahl mit N = -N;
dem Zweierkomplement in die entsprechende positive Zahl umzuwandeln. Die maximal negative Zahl hat keine entsprechende positive Zahl, es sei denn, Sie fördern Sie es zu einem größeren Typ. Eine Möglichkeit, dies zu umgehen, besteht darin, die Nummer dem entsprechenden vorzeichenlosen Typ zuzuordnen (dies ist jedoch nicht trivial).
'
-flag gerichtet ist: stackoverflow.com/q/44523855/2642059 Ich denke, diese Antwort spricht das perfekt an und führt jetzt weitere Tests durch. Wenn ja, sollte ich diese Frage wohl als Betrug markieren, oder?
tsep
, place_str
und neg_str
überhaupt? Warum nicht einfach die fmt_info
Mitglieder direkt nutzen ?
while (*ptr-- = *neg_str++)
macht für mich nicht viel Sinn. Sie fügen die negativen Zeichenfolgen in umgekehrter Reihenfolge ein.
Ohne Rekursion oder String-Behandlung ein mathematischer Ansatz:
#include <stdio.h>
#include <math.h>
void print_number( int n )
{
int order_of_magnitude = (n == 0) ? 1 : (int)pow( 10, ((int)floor(log10(abs(n))) / 3) * 3 ) ;
printf( "%d", n / order_of_magnitude ) ;
for( n = abs( n ) % order_of_magnitude, order_of_magnitude /= 1000;
order_of_magnitude > 0;
n %= order_of_magnitude, order_of_magnitude /= 1000 )
{
printf( ",%03d", abs(n / order_of_magnitude) ) ;
}
}
Im Prinzip ähnlich wie bei Pax 'rekursiver Lösung, aber durch vorherige Berechnung der Größenordnung wird eine Rekursion vermieden (möglicherweise mit erheblichem Aufwand).
Beachten Sie auch, dass das tatsächliche Zeichen, das zum Trennen von Tausenden verwendet wird, länderspezifisch ist.
Bearbeiten : Verbesserungen finden Sie in den Kommentaren von @ Chux unten.
abs(n)
auf fabs(n)
verhindert den Komplimentfehler von 2 bei der Ausführung print_number(INT_MIN)
.
log10(abs(n))
und nicht anderswo gedacht . Interessanterweise funktioniert Ihre Lösung mit der einmaligen Änderung von log10(fabs(n))
und print_number(INT_MIN)
aufgrund dessen, printf(..., abs(n / order_of_magnitude))
was bedeutet, n = abs(INT_MIN) % order_of_magnitude
dass es in Ordnung ist, negativ zu sein. Wenn wir INT_MIN aufgeben, printf(..., abs(n / order_of_magnitude))
kann das werden printf(..., n / order_of_magnitude)
. Aber ich nehme an, die Arbeit mit diesem Wurm namens "abs (INT_MIN)" ist normalerweise eine schlechte Sache.
log10(fabs(n))
, n = abs(n% order_of_magnitude)
und printf(",%03d", n/order_of_magnitude)
. Übrigens: Ich würde diese Mühe nicht aufwenden, wenn ich nicht denke, dass Ihre Lösung gut ist. Keine UB, auch für INT_MIN.
Basierend auf @Greg Hewgills, berücksichtigt jedoch negative Zahlen und gibt die Zeichenfolgengröße zurück.
size_t str_format_int_grouped(char dst[16], int num)
{
char src[16];
char *p_src = src;
char *p_dst = dst;
const char separator = ',';
int num_len, commas;
num_len = sprintf(src, "%d", num);
if (*p_src == '-') {
*p_dst++ = *p_src++;
num_len--;
}
for (commas = 2 - num_len % 3;
*p_src;
commas = (commas + 1) % 3)
{
*p_dst++ = *p_src++;
if (commas == 1) {
*p_dst++ = separator;
}
}
*--p_dst = '\0';
return (size_t)(p_dst - dst);
}
Meine Antwort formatiert das Ergebnis nicht genau wie die Abbildung in der Frage, kann jedoch in einigen Fällen den tatsächlichen Bedarf mit einem einfachen Einzeiler oder Makro decken. Man kann es erweitern, um bei Bedarf mehr als tausend Gruppen zu generieren.
Das Ergebnis sieht beispielsweise wie folgt aus:
Value: 0'000'012'345
Der Code:
printf("Value: %llu'%03lu'%03lu'%03lu\n", (value / 1000 / 1000 / 1000), (value / 1000 / 1000) % 1000, (value / 1000) % 1000, value % 1000);
'
eine Standardnotation entspricht einem ,
(mathematisch, zumindest) in einem Teil (e) der Welt?
In C gibt es keine wirklich einfache Möglichkeit, dies zu tun. Ich würde einfach eine Int-to-String-Funktion ändern, um dies zu tun:
void format_number(int n, char * out) {
int i;
int digit;
int out_index = 0;
for (i = n; i != 0; i /= 10) {
digit = i % 10;
if ((out_index + 1) % 4 == 0) {
out[out_index++] = ',';
}
out[out_index++] = digit + '0';
}
out[out_index] = '\0';
// then you reverse the out string as it was converted backwards (it's easier that way).
// I'll let you figure that one out.
strrev(out);
}
Eine weitere iterative Funktion
int p(int n) {
if(n < 0) {
printf("-");
n = -n;
}
int a[sizeof(int) * CHAR_BIT / 3] = { 0 };
int *pa = a;
while(n > 0) {
*++pa = n % 1000;
n /= 1000;
}
printf("%d", *pa);
while(pa > a + 1) {
printf(",%03d", *--pa);
}
}
Hier ist die schlankste, größen- und geschwindigkeitseffiziente Implementierung dieser Art der Dezimalstellenformatierung:
const char *formatNumber (
int value,
char *endOfbuffer,
bool plus)
{
int savedValue;
int charCount;
savedValue = value;
if (unlikely (value < 0))
value = - value;
*--endOfbuffer = 0;
charCount = -1;
do
{
if (unlikely (++charCount == 3))
{
charCount = 0;
*--endOfbuffer = ',';
}
*--endOfbuffer = (char) (value % 10 + '0');
}
while ((value /= 10) != 0);
if (unlikely (savedValue < 0))
*--endOfbuffer = '-';
else if (unlikely (plus))
*--endOfbuffer = '+';
return endOfbuffer;
}
Verwenden Sie wie folgt:
char buffer[16];
fprintf (stderr, "test : %s.", formatNumber (1234567890, buffer + 16, true));
Ausgabe:
test : +1,234,567,890.
Einige Vorteile:
Funktion, die das Ende des Zeichenfolgenpuffers aufgrund der Formatierung in umgekehrter Reihenfolge übernimmt. Schließlich, wo es nicht nötig ist, generierte Zeichenfolgen (strrev) zu verehren.
Diese Funktion erzeugt eine Zeichenfolge, die in jedem Algo danach verwendet werden kann. Es hängt nicht davon ab und erfordert nicht mehrere printf / sprintf-Aufrufe, was schrecklich langsam und immer kontextspezifisch ist.
unlikely
?
unlikely
ist wahrscheinlich ein Hinweis für den Optimierer, dass die Bedingung wahrscheinlich nicht wahr ist. Weitere Informationen finden Sie unter likely()
/ unlikely()
macros im Linux-Kernel .
Sichere format_commas mit negativen Zahlen:
Da VS <2015 snprintf nicht implementiert, müssen Sie dies tun
#if defined(_WIN32)
#define snprintf(buf,len, format,...) _snprintf_s(buf, len,len, format, __VA_ARGS__)
#endif
Und dann
char* format_commas(int n, char *out)
{
int c;
char buf[100];
char *p;
char* q = out; // Backup pointer for return...
if (n < 0)
{
*out++ = '-';
n = abs(n);
}
snprintf(buf, 100, "%d", n);
c = 2 - strlen(buf) % 3;
for (p = buf; *p != 0; p++) {
*out++ = *p;
if (c == 1) {
*out++ = '\'';
}
c = (c + 1) % 3;
}
*--out = 0;
return q;
}
Anwendungsbeispiel:
size_t currentSize = getCurrentRSS();
size_t peakSize = getPeakRSS();
printf("Current size: %d\n", currentSize);
printf("Peak size: %d\n\n\n", peakSize);
char* szcurrentSize = (char*)malloc(100 * sizeof(char));
char* szpeakSize = (char*)malloc(100 * sizeof(char));
printf("Current size (f): %s\n", format_commas((int)currentSize, szcurrentSize));
printf("Peak size (f): %s\n", format_commas((int)currentSize, szpeakSize));
free(szcurrentSize);
free(szpeakSize);
Eine modifizierte Version der @ paxdiablo-Lösung, jedoch mit WCHAR
und wsprinf
:
static WCHAR buffer[10];
static int pos = 0;
void printfcomma(const int &n) {
if (n < 0) {
wsprintf(buffer + pos, TEXT("-"));
pos = lstrlen(buffer);
printfcomma(-n);
return;
}
if (n < 1000) {
wsprintf(buffer + pos, TEXT("%d"), n);
pos = lstrlen(buffer);
return;
}
printfcomma(n / 1000);
wsprintf(buffer + pos, TEXT(",%03d"), n % 1000);
pos = lstrlen(buffer);
}
void my_sprintf(const int &n)
{
pos = 0;
printfcomma(n);
}
Ich bin neu in der C-Programmierung. Hier ist mein einfacher Code.
int main()
{
// 1223 => 1,223
int n;
int a[10];
printf(" n: ");
scanf_s("%d", &n);
int i = 0;
while (n > 0)
{
int temp = n % 1000;
a[i] = temp;
n /= 1000;
i++;
}
for (int j = i - 1; j >= 0; j--)
{
if (j == 0)
{
printf("%d.", a[j]);
}
else printf("%d,",a[j]);
}
getch();
return 0;
}
#include <stdio.h>
void punt(long long n){
char s[28];
int i = 27;
if(n<0){n=-n; putchar('-');}
do{
s[i--] = n%10 + '0';
if(!(i%4) && n>9)s[i--]='.';
n /= 10;
}while(n);
puts(&s[++i]);
}
int main(){
punt(2134567890);
punt(987);
punt(9876);
punt(-987);
punt(-9876);
punt(-654321);
punt(0);
punt(1000000000);
punt(0x7FFFFFFFFFFFFFFF);
punt(0x8000000000000001); // -max + 1 ...
}
Meine Lösung verwendet a. Anstelle von a bleibt es dem Leser überlassen, dies zu ändern.
Dies ist alt und es gibt viele Antworten, aber die Frage war nicht "Wie kann ich eine Routine schreiben, um Kommas hinzuzufügen", sondern "Wie kann das in C gemacht werden"? Die Kommentare wiesen auf diese Richtung hin, aber auf meinem Linux-System mit GCC funktioniert dies für mich:
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main()
{
unsetenv("LC_ALL");
setlocale(LC_NUMERIC, "");
printf("%'lld\n", 3141592653589);
}
Wenn dies ausgeführt wird, erhalte ich:
$ cc -g comma.c -o comma && ./comma
3,141,592,653,589
Wenn ich die LC_ALL
Variable vor dem Ausführen des Programms deaktiviere, unsetenv
ist dies nicht erforderlich.
Musste etwas Ähnliches selbst machen, aber anstatt direkt zu drucken, musste ich in einen Puffer gehen. Folgendes habe ich mir ausgedacht. Funktioniert rückwärts.
unsigned int IntegerToCommaString(char *String, unsigned long long Integer)
{
unsigned int Digits = 0, Offset, Loop;
unsigned long long Copy = Integer;
do {
Digits++;
Copy /= 10;
} while (Copy);
Digits = Offset = ((Digits - 1) / 3) + Digits;
String[Offset--] = '\0';
Copy = Integer;
Loop = 0;
do {
String[Offset] = '0' + (Copy % 10);
if (!Offset--)
break;
if (Loop++ % 3 == 2)
String[Offset--] = ',';
Copy /= 10;
} while (1);
return Digits;
}
Beachten Sie, dass es nur für vorzeichenlose Ganzzahlen ausgelegt ist und Sie sicherstellen müssen, dass der Puffer groß genug ist.
Eine andere Lösung besteht darin, das Ergebnis in einem int
Array mit einer maximalen Größe von 7 zu speichern, da der long long int
Typ Zahlen im Bereich von 9.223.372.036.854.775.807 bis -9.223.372.036.854.775.807 verarbeiten kann . (Beachten Sie, dass es sich nicht um einen vorzeichenlosen Wert handelt.)
Nicht rekursive Druckfunktion
static void printNumber (int numbers[8], int loc, int negative)
{
if (negative)
{
printf("-");
}
if (numbers[1]==-1)//one number
{
printf("%d ", numbers[0]);
}
else
{
printf("%d,", numbers[loc]);
while(loc--)
{
if(loc==0)
{// last number
printf("%03d ", numbers[loc]);
break;
}
else
{ // number in between
printf("%03d,", numbers[loc]);
}
}
}
}
Hauptfunktionsaufruf
static void getNumWcommas (long long int n, int numbers[8])
{
int i;
int negative=0;
if (n < 0)
{
negative = 1;
n = -n;
}
for(i = 0; i < 7; i++)
{
if (n < 1000)
{
numbers[i] = n;
numbers[i+1] = -1;
break;
}
numbers[i] = n%1000;
n/=1000;
}
printNumber(numbers, i, negative);// non recursive print
}
Ausgabe testen
-9223372036854775807: -9,223,372,036,854,775,807
-1234567890 : -1,234,567,890
-123456 : -123,456
-12345 : -12,345
-1000 : -1,000
-999 : -999
-1 : -1
0 : 0
1 : 1
999 : 999
1000 : 1,000
12345 : 12,345
123456 : 123,456
1234567890 : 1,234,567,890
9223372036854775807 : 9,223,372,036,854,775,807
In der main () Funktion:
int numberSeparated[8];
long long int number = 1234567890LL;
getNumWcommas(number, numberSeparated);
Wenn nur gedruckt werden muss, gehen Sie int numberSeparated[8];
in die Funktion getNumWcommas
und rufen Sie sie so auf getNumWcommas(number)
.
Kann ziemlich einfach gemacht werden ...
//Make sure output buffer is big enough and that input is a valid null terminated string
void pretty_number(const char* input, char * output)
{
int iInputLen = strlen(input);
int iOutputBufferPos = 0;
for(int i = 0; i < iInputLen; i++)
{
if((iInputLen-i) % 3 == 0 && i != 0)
{
output[iOutputBufferPos++] = ',';
}
output[iOutputBufferPos++] = input[i];
}
output[iOutputBufferPos] = '\0';
}
Beispielaufruf:
char szBuffer[512];
pretty_number("1234567", szBuffer);
//strcmp(szBuffer, "1,234,567") == 0
void printfcomma ( long long unsigned int n)
{
char nstring[100];
int m;
int ptr;
int i,j;
sprintf(nstring,"%llu",n);
m=strlen(nstring);
ptr=m%3;
if (ptr)
{ for (i=0;i<ptr;i++) // print first digits before comma
printf("%c", nstring[i]);
printf(",");
}
j=0;
for (i=ptr;i<m;i++) // print the rest inserting commas
{
printf("%c",nstring[i]);
j++;
if (j%3==0)
if(i<(m-1)) printf(",");
}
}
,
für die unten stehenden Zahlen 100
, verwendet, printf()
wo putchar()
fliegen würde, verwendet irreführende Namen, chaotische Einrückungen und viel zu viel Code.
// separate thousands
int digit;
int idx = 0;
static char buffer[32];
char* p = &buffer[32];
*--p = '\0';
for (int i = fCounter; i != 0; i /= 10)
{
digit = i % 10;
if ((p - buffer) % 4 == 0)
*--p = ' ';
*--p = digit + '0';
}
idx
könnte gehen. Der Code erzeugt nichts für 0. Er verarbeitet keine negativen Zahlen. Es gibt keinen offensichtlichen Grund, buffer
eine static
Variable zu erstellen (dies schränkt die Wiedereintrittsfähigkeit des Codes ein). Es gibt keine Erklärung dafür, was es tut, oder es wird erwähnt, dass die Zeichenfolge, auf die durch gezeigt wird, nach Abschluss des Codes p
die formatierte Zeichenfolge enthält. Das am wenigsten schwerwiegende Problem ist, dass Leerzeichen anstelle von Komma als Tausendertrennzeichen verwendet werden. Die Tatsache, dass es nicht mit Null umgeht, ist jedoch das Killerproblem.
printf()
Familie der formatierten E / A-Funktionen (das einfache Anführungszeichen: ') ist ein nicht standardmäßiges Flag, das nur in einigen Bibliotheksimplementierungen unterstützt wird. Es ist schade, dass es nicht Standard ist.