कैसे कर सकते हैं मैं सी भाषा प्रारूप में से एक नंबर 1123456789के लिए 1,123,456,789? मैं का उपयोग करने की कोशिश की, printf("%'10d\n", 1123456789);लेकिन यह काम नहीं करता है।
क्या आप कुछ भी सलाह दे सकते हैं? समाधान जितना आसान होगा उतना ही अच्छा होगा।
LC_NUMERIC। हालाँकि, मुझे नहीं पता कि यह किस लोकेल का समर्थन करता है।
LC_NUMERICलोकल को करंट में सेट करना मेरे मैक पर काम ""करता है 'और एक लाइनक्स मशीन पर जिसे मैंने अभी चेक किया है।
printf()फ़ंक्शन के परिवार के POSIX 2008 (2013) संस्करण 'दशमलव संख्या स्वरूपण विनिर्देशों के साथ (एकल उद्धरण या एपोस्ट्रोफ़) वर्ण के उपयोग को मानकीकृत करते हैं ताकि यह निर्दिष्ट किया जा सके कि संख्या को हजारों विभाजकों के साथ स्वरूपित किया जाना चाहिए।
"C"लोकेल में, गैर-मौद्रिक हजारों विभाजक अपरिभाषित हैं, इसलिए लोकेल "%'d"में कॉमा उत्पन्न नहीं करेगा "C"। आपको एक उपयुक्त गैर-मौद्रिक हजार विभाजक के साथ एक स्थान निर्धारित करने की आवश्यकता है। अक्सर, setlocale(LC_ALL, "");काम करेंगे - स्थानीय नाम (खाली स्ट्रिंग के अलावा) के लिए अन्य मूल्यों को परिभाषित किया गया है।
जवाबों:
यदि आपका प्रिंटफ़ 'फ्लैग का समर्थन करता है (जैसा कि POSIX 2008 के लिए आवश्यक है printf()), तो आप इसे उचित रूप से अपना लोकेल सेट करके ही कर सकते हैं। उदाहरण:
#include <stdio.h>
#include <locale.h>
int main(void)
{
setlocale(LC_NUMERIC, "");
printf("%'d\n", 1123456789);
return 0;
}
और निर्माण और चलाने:
$ ./example
1,123,456,789
मैक ओएस एक्स और लिनक्स (उबंटू 10.10) पर परीक्षण किया गया।
sprintf()एक एम्बेडेड सिस्टम में इस पर परीक्षण किया है और यह काम नहीं करता है (जाहिर है, क्योंकि जैसा कि आप कहते हैं, यह 'ध्वज का समर्थन नहीं करेगा।
'आपरिवर्तक। हेडर से: Copyright ... 2007 Joerg Wunsch ... 1993 Regents of the University of Californiaयानी एक बीएसडी व्युत्पन्न।
आप इसे निम्नानुसार कर सकते हैं (सावधान रहें INT_MINयदि आप दो के पूरक का उपयोग कर रहे हैं, तो आपको इसे प्रबंधित करने के लिए अतिरिक्त कोड की आवश्यकता होगी):
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);
}
एक सारांश:
printfcommaएक पूर्णांक के साथ कॉल करता है , नकारात्मक संख्याओं के विशेष मामले को केवल "-" और संख्या को सकारात्मक बनाते हुए नियंत्रित किया जाता है (यह वह बिट है जो काम नहीं करेगा INT_MIN)।printfcomma2, तो 1,000 से कम की संख्या सिर्फ प्रिंट और वापस आ जाएगी।अधिक रसीला संस्करण भी है, हालांकि यह हर स्तर पर नकारात्मक संख्याओं की जांच करने में अनावश्यक प्रसंस्करण करता है (ऐसा नहीं है कि यह सीमित संख्या में पुनरावृत्ति स्तरों को बताएगा)। यह एक परीक्षण का पूरा कार्यक्रम है:
#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;
}
और आउटपुट है:
-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
उन लोगों के लिए एक पुनरावृत्ति समाधान, जो पुनरावृत्ति पर भरोसा नहीं करते हैं (हालांकि पुनरावृत्ति के साथ एकमात्र समस्या स्टैक स्पेस होती है, जो यहां एक मुद्दा नहीं होगा क्योंकि यह 64-बिट पूर्णांक के लिए भी कुछ ही स्तर गहरा होगा):
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);
}
}
इन दोनों के 2,147,483,647लिए उत्पन्न करते हैं INT_MAX।
उपरोक्त सभी कोड अल्प-पृथक तीन-अंकीय समूहों के लिए है, लेकिन आप अन्य वर्णों का भी उपयोग कर सकते हैं, जैसे कि एक स्थान:
void printfspace2 (int n) {
if (n < 1000) {
printf ("%d", n);
return;
}
printfspace2 (n/1000);
printf (" %03d", n%1000);
}
void printfspace (int n) {
if (n < 0) {
printf ("-");
n = -n;
}
printfspace2 (n);
}
nहै printfcomma। आपको इसे नकारने से पहले किसी रूपांतरण को बाध्य करने की आवश्यकता है।
printf।
यहाँ एक बहुत ही सरल कार्यान्वयन है। इस फ़ंक्शन में कोई त्रुटि जाँच नहीं है, कॉलर द्वारा बफर आकारों को सत्यापित किया जाना चाहिए। यह नकारात्मक संख्याओं के लिए भी काम नहीं करता है। ऐसे सुधार पाठक के लिए एक अभ्यास के रूप में छोड़ दिए जाते हैं।
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;
}
ओह नहीं! मैं हर समय ऐसा करता हूं, linux पर gcc / g ++ और glibc का उपयोग करके, और 'ऑपरेटर गैर-मानक हो सकता है, लेकिन मुझे इसकी सरलता पसंद है।
#include <stdio.h>
#include <locale.h>
int main()
{
int bignum=12345678;
setlocale(LC_ALL,"");
printf("Big number: %'d\n",bignum);
return 0;
}
का आउटपुट देता है:
बड़ी संख्या: 12,345,678
बस वहां पर 'सेटलोकेले' कॉल को याद रखना होगा, अन्यथा यह कुछ भी प्रारूपित नहीं करेगा।
'ध्वज का समर्थन नहीं करती है , तो आपको वांछित आउटपुट नहीं मिलता है - और यह कंपाइलर से स्वतंत्र है। संकलक यह सुनिश्चित करता है कि लाइब्रेरी फ़ंक्शन printf()को प्रारूप स्ट्रिंग के साथ बुलाया जाए; यह व्याख्या करने के लिए पुस्तकालय समारोह पर निर्भर है। विंडोज पर, यह पूरी तरह से संभव है कि सीआरटी पुस्तकालय आपको आवश्यक समर्थन प्रदान नहीं करता है - और यह मायने नहीं रखता है कि आप किस कंपाइलर का उपयोग करते हैं।
शायद एक स्थानीय-जागरूक संस्करण दिलचस्प होगा।
#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
यह एक बग है (लेकिन एक मैं काफी मामूली विचार करेंगे)। दो के पूरक हार्डवेयर पर, यह सबसे-ऋणात्मक संख्या को सही ढंग से परिवर्तित नहीं करेगा, क्योंकि यह नकारात्मक संख्या को इसके समकक्ष सकारात्मक संख्या में बदलने का प्रयास करता है N = -N;। दो के पूरक में, अधिकतम नकारात्मक संख्या में एक समान धनात्मक संख्या नहीं होती है, जब तक कि आप इसे बड़े प्रकार तक बढ़ावा दें। इसके चारों ओर जाने का एक तरीका संख्या को संबंधित अहस्ताक्षरित प्रकार को बढ़ावा देना है (लेकिन यह कुछ हद तक गैर-तुच्छ है)।
'फ़्लैग के क्रॉस प्लेटफ़ॉर्म कार्यान्वयन के लिए और अधिक निर्देश यहां दिए गए हैं: stackoverflow.com/q/44523855/2642059 मुझे लगता है कि यह जवाब पूरी तरह से पता है कि, अब और परीक्षण कर रहा है। अगर ऐसा है तो मुझे लगता है कि मुझे उस सवाल को एक ठग के रूप में चिह्नित करना चाहिए?
tsep, place_str, और neg_strसब पर? क्यों नहीं सीधे सीधे fmt_infoसदस्यों का उपयोग करें ?
while (*ptr-- = *neg_str++)इससे मुझे कोई मतलब नहीं है। आप नकारात्मक स्ट्रिंग वर्णों को उल्टे क्रम में सम्मिलित कर रहे हैं।
पुनरावृत्ति या स्ट्रिंग हैंडलिंग के बिना, एक गणितीय दृष्टिकोण:
#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) ) ;
}
}
पैक्स के पुनरावर्ती समाधान के सिद्धांत में समान है, लेकिन अग्रिम में परिमाण के क्रम की गणना करके, पुनरावृत्ति से बचा जाता है (कुछ काफी व्यय पर)।
यह भी ध्यान दें कि हजारों को अलग करने के लिए उपयोग किया जाने वाला वास्तविक चरित्र स्थानीय विशिष्ट है।
संपादित करें : सुधार के लिए नीचे @ Chux की टिप्पणियां देखें।
abs(n)के लिए fabs(n)रोकता है 2 के तारीफ त्रुटि प्रदर्शन print_number(INT_MIN)।
log10(abs(n))और कहीं नहीं के लिए था। दिलचस्प बात यह है अपने समाधान करने के लिए एक परिवर्तन के साथ काम करता log10(fabs(n))है और print_number(INT_MIN)इस वजह से printf(..., abs(n / order_of_magnitude))जो साधन n = abs(INT_MIN) % order_of_magnitudeनकारात्मक किया जा रहा है ठीक है। अगर हम INT_MIN पर हार मानते हैं, तो printf(..., abs(n / order_of_magnitude))बन सकते हैं printf(..., n / order_of_magnitude)। लेकिन मुझे लगता है कि "एब्स (INT_MIN)" नामक कीड़ा के साथ काम करना आमतौर पर एक बुरी बात है।
log10(fabs(n)), n = abs(n% order_of_magnitude)और printf(",%03d", n/order_of_magnitude)। BTW: मैं इस प्रयास को तब तक नहीं बिताऊंगा जब तक मुझे नहीं लगता कि आप समाधान अच्छा था। INT_MIN के लिए भी कोई UB नहीं।
@Greg Hewgill के आधार पर, लेकिन नकारात्मक संख्याओं को ध्यान में रखता है और स्ट्रिंग आकार को लौटाता है।
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);
}
मेरा उत्तर वास्तव में प्रश्न में चित्रण की तरह परिणाम को प्रारूपित नहीं करता है, लेकिन एक साधारण एक-लाइनर या मैक्रो के साथ कुछ मामलों में वास्तविक आवश्यकता को पूरा कर सकता है । आवश्यक के रूप में अधिक हजार-समूह उत्पन्न करने के लिए इसका विस्तार किया जा सकता है।
परिणाम उदाहरण के लिए दिखेगा:
Value: 0'000'012'345
कोड:
printf("Value: %llu'%03lu'%03lu'%03lu\n", (value / 1000 / 1000 / 1000), (value / 1000 / 1000) % 1000, (value / 1000) % 1000, value % 1000);
'एक मानक अंकन ,(गणितीय रूप से, कम से कम) के बराबर है ?
सी में ऐसा करने का कोई वास्तविक सरल तरीका नहीं है। मैं इसे करने के लिए एक इंट-टू-स्ट्रिंग फ़ंक्शन को संशोधित करूंगा:
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);
}
एक और पुनरावृत्त समारोह
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);
}
}
इस प्रकार के दशमलव अंकों को बनाने का सबसे पतला, आकार और गति कुशल कार्यान्वयन है:
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;
}
निम्नानुसार उपयोग करें:
char buffer[16];
fprintf (stderr, "test : %s.", formatNumber (1234567890, buffer + 16, true));
आउटपुट:
test : +1,234,567,890.
कुछ फायदे:
रिवर्स ऑर्डर किए गए फॉर्मेटिंग के कारण स्ट्रिंग बफर के अंत में कार्य करना। अंत में, उत्पन्न स्ट्रिंग (स्ट्रिव) को वापस करने की कोई आवश्यकता नहीं है।
यह फ़ंक्शन एक स्ट्रिंग का उत्पादन करता है जिसे बाद में किसी भी अहंकार में इस्तेमाल किया जा सकता है। यह निर्भर नहीं करता है और न ही कई प्रिंटफ / स्प्रिंटफ कॉल की आवश्यकता है, जो भयानक धीमी और हमेशा संदर्भ विशिष्ट है।
unlikely?
unlikelyसंभवतः ऑप्टिमाइज़र को संकेत है कि स्थिति सही होने की संभावना नहीं है। अधिक जानकारी के लिए लिनक्स कर्नेल में देखें likely()/ unlikely()मैक्रो ।
नेगेटिव नंबरों के साथ फ़ॉर्मेट_कम करें,
क्योंकि वीएस <2015 स्निपरफ को लागू नहीं करता है, आपको ऐसा करने की आवश्यकता है
#if defined(_WIN32)
#define snprintf(buf,len, format,...) _snprintf_s(buf, len,len, format, __VA_ARGS__)
#endif
और तब
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;
}
उदाहरण उपयोग:
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);
@Paxdiablo समाधान का एक संशोधित संस्करण, लेकिन उपयोग WCHARऔर 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);
}
मैं C प्रोग्रामिंग में नया हूँ। यहाँ मेरा सरल कोड है।
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 ...
}
मेरे समाधान का उपयोग करता है a। इसके बजाय इसे बदलने के लिए पाठक पर छोड़ दिया जाता है।
यह पुराना है और इसके बहुत सारे उत्तर हैं लेकिन सवाल यह नहीं था कि "मैं कॉमा को जोड़ने के लिए एक दिनचर्या कैसे लिख सकता हूं" लेकिन "यह सी में कैसे किया जा सकता है"? टिप्पणियों ने इस दिशा की ओर इशारा किया लेकिन जीसीसी के साथ मेरे लिनक्स सिस्टम पर, यह मेरे लिए काम करता है:
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main()
{
unsetenv("LC_ALL");
setlocale(LC_NUMERIC, "");
printf("%'lld\n", 3141592653589);
}
जब यह चलाया जाता है, तो मुझे मिलता है:
$ cc -g comma.c -o comma && ./comma
3,141,592,653,589
यदि मैं LC_ALLप्रोग्राम को चलाने से पहले वेरिएबल को अनसेट करता हूं , unsetenvतो यह आवश्यक नहीं है।
खुद कुछ ऐसा ही करने की जरूरत है, बल्कि सीधे छापने के बजाय, एक बफर में जाने की जरूरत है। यहाँ मैं क्या लेकर आया हूँ। पीछे की ओर काम करता है।
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;
}
ध्यान रखें कि यह केवल अहस्ताक्षरित पूर्णांक के लिए डिज़ाइन किया गया है और आपको यह सुनिश्चित करना होगा कि बफर काफी बड़ा है।
एक अन्य समाधान, परिणाम को एक intसरणी में सहेजकर , अधिकतम 7 का आकार क्योंकि long long intप्रकार 9,223,372,036,854,775,807 से -9,223,372,036,854,785,807 की सीमा में संख्या को संभाल सकता है । (ध्यान दें कि यह एक अहस्ताक्षरित मूल्य नहीं है)।
गैर-पुनरावर्ती मुद्रण कार्य
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]);
}
}
}
}
मुख्य समारोह कॉल
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
}
परीक्षण उत्पादन
-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
मुख्य () फ़ंक्शन में:
int numberSeparated[8];
long long int number = 1234567890LL;
getNumWcommas(number, numberSeparated);
यदि मुद्रण की आवश्यकता है, तो int numberSeparated[8];फ़ंक्शन के अंदर जाएं getNumWcommasऔर इसे इस तरह से कॉल करें getNumWcommas(number)।
बहुत आसानी से किया जा सकता है ...
//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';
}
उदाहरण कॉल:
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(",");
}
}
,नीचे दिए गए नंबरों के लिए एक अतिरिक्त प्रिंट 100करता है, उपयोग करता है printf()जहां putchar()उड़ जाएगा, भ्रामक नाम, अराजक इंडेंटेशन और बहुत अधिक कोड का उपयोग करता है।
// 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जा सकता है। कोड 0. के लिए कुछ भी उत्पादन नहीं करता है। यह नकारात्मक संख्याओं को संभालता नहीं है। bufferएक staticचर बनाने का कोई स्पष्ट कारण नहीं है (यह कोड की पुनर्व्यवस्थितता को सीमित करता है)। इसका कोई स्पष्टीकरण नहीं है कि यह क्या करता है, या यह उल्लेख करता है कि कोड पूरा होने के बाद, स्ट्रिंग द्वारा इंगित स्ट्रिंग pमें स्वरूपित स्ट्रिंग शामिल है। सबसे कम गंभीर समस्या यह है कि यह हजारों विभाजक के रूप में अल्पविराम के बजाय रिक्त का उपयोग करता है। तथ्य यह है कि यह शून्य को संभाल नहीं करता है, हालांकि हत्यारा समस्या है।
printf()स्वरूपित IO फ़ंक्शंस (एकल-भाव वर्ण: ') के परिवार के लिए' हजारों विभाजक 'ध्वज एक गैर-मानक ध्वज है जो केवल कुछ लाइब्रेरी कार्यान्वयन में समर्थित है। यह बहुत बुरा है कि यह मानक नहीं है।