C में 1,000,000,000 को 1000 * 1000 * 1000 के रूप में क्यों लिखें?

Question

Apple द्वारा बनाए गए कोड में, यह रेखा है:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

के 1,000,000,000रूप में व्यक्त करने का कोई कारण है 1000*1000*1000?

1000^3उस बात के लिए क्यों नहीं ?

Comments

कोड की स्पष्टता और पठनीयता। आप C में विभाजक के रूप में 'या' नहीं डाल सकते हैं, इसलिए अगली सबसे अच्छी बात गुणन से मूल्य की गणना करना है। ^ C - अनन्य OR में एक असंबंधित ऑपरेटर है।

— इविलनोटिक्सिस्ट इडोनाटेक्सिस्ट

यह विशेष रूप से अवधि के लिए उपयोग किया जाता है: 2 * 60 * 60 .. इसकी सूचना जो 2hours के लिए आसान है ..

— इडली

एक के लिए मुझे संदेह है कि 1,000,000,000 वैध वाक्यविन्यास नहीं है

— paparazzo

वैसे, आधुनिक प्रोग्रामिंग भाषाओं के पास वैसा ही लिखने का वैकल्पिक तरीका है, जैसे स्विफ्ट में 1_000_000_000। हालांकि, समय की कमी के साथ यह अधिक कठिन है। यह लिखने की 30 * 60तुलना में (सेकंड में 30 मिनट) लिखने के लिए अधिक पठनीय है 1800। वास्तव में ऐसी भाषाएं हैं जो आपको इकाइयों को लिखने की अनुमति देंगी, उदाहरण के लिए meters, आपको खराब असाइनमेंट के खिलाफ खुद को बचाने की अनुमति देता है।

— सुल्तान

^एक एक्सओआर है, न कि एक प्रतिपादक या बिजली ऑपरेटर।

— डीएवी

Answer 1

स्थाई रूप से स्थिरांक घोषित करने का एक कारण पठनीयता में सुधार करना है, जबकि रन-टाइम प्रदर्शन प्रभावित नहीं होता है। इसके अलावा, यह इंगित करने के लिए कि लेखक संख्या के बारे में गुणात्मक तरीके से सोच रहा था।

इस पर विचार करो:

double memoryBytes = 1024 * 1024 * 1024;

यह स्पष्ट रूप से बेहतर है:

double memoryBytes = 1073741824;

जैसा कि उत्तरार्द्ध नहीं दिखता है, पहली नज़र में, 1024 की तीसरी शक्ति।

जैसा कि अमीन नेगम-अवाद ने उल्लेख किया है, ^ऑपरेटर द्विआधारी है XOR। कई भाषाओं में बिल्ट-इन, संकलन-समय प्रतिपादक ऑपरेटर की कमी है, इसलिए गुणन।

Comments

और जिन भाषाओं में प्रतिपादक ऑपरेटर होता है, वह जरूरी नहीं कि '^' हो। उदाहरण के लिए, फोरट्रान में, यह '**' है।

— जेमसेकफ

आपको @chux: stackoverflow.com/a/40637622/1841533 से विशेष रूप से नीचे दिए गए उत्तर में दिए गए महत्वपूर्ण कैविएट की ओर इशारा करते हुए एक लिंक भी शामिल करना चाहिए (विशेषकर जैसा कि ओपी ने "सी" टैग किया है, जो इस 'righ-hand' के लिए बहुत ही संवेदनशील है) ऐसा लगता है कि सभी ऑपरेशन छोटे प्रकार तक ही सीमित हैं, और इसलिए गुणन 'समस्या' को खत्म कर सकता है। safecoding.cert.org/confluence/display/c/… सामान्य स्थिति में उन लोगों से बचने में मदद कर सकता है?

— ओलिवियर दुलाक

हमें यह भी ध्यान देना चाहिए कि गणना संकलन के समय की जाती है। C मानक को भाषा की विभिन्न विशेषताओं के लिए संकलन-समय पर निरंतर अभिव्यक्ति की गणना करने में सक्षम होने के लिए कार्यान्वयन की आवश्यकता होती है और हम इस उदाहरण में एक स्थिर अभिव्यक्ति का उपयोग किए जाने पर सुरक्षित रूप से सत्य हो सकते हैं।

— ahउउह

एक डबल के रूप में मेमोरी की मात्रा? यह त्रुटि के संभावित स्रोत की तरह लगता है।

— JAB

@supercat मैं इसके बारे में जानता हूं, लेकिन डबल का उपयोग करके आप एक केस कर सकते हैं, जहां, कह सकते हैं, आप मेमोरी रेंज का एक हिस्सा चाहते हैं, आप सबरेंज xका आकार प्राप्त करने के लिए विभाजित करते हैं ... और अचानक आपके पास एक अंश है बाइट, जिसकी भरपाई के लिए अतिरिक्त तर्क की आवश्यकता हो सकती है।

— जेएबी

Answer 2

क्यों नहीं 1000^3?

का परिणाम 1000^31003 ^है। बिट-एक्सओआर ऑपरेटर है।

यहां तक ​​कि यह स्वयं क्यू के साथ सौदा नहीं करता है, मैं एक स्पष्टीकरण जोड़ता हूं। x^yकरता नहीं हमेशा के रूप में मूल्यांकित x+yके रूप में यह प्रश्नकर्ता के उदाहरण में करता है। आपको हर बिट को एक्सर करना होगा। उदाहरण के मामले में:

1111101000₂ (1000₁₀)
0000000011₂ (3₁₀)
1111101011₂ (1003₁₀)

परंतु

1111101001₂ (1001₁₀)
0000000011₂ (3₁₀)
1111101010₂ (1002₁₀)

Comments

महोदय, मुझे यह स्पष्ट नहीं है कि 1003 ^ 3 1003 है। Google और मैक कैलकुलेटर 1000 ^ 3 = 1,000,000,000 दिखाता है। क्या तुम समझा सकते हो?

— महेश

^C / C ++ / ऑब्जेक्टिव-सी आदि कैलकुलेटर में यह आम तौर पर मतलब है एक्स-टू--y सत्ता में ऑपरेटर साधन XOR।

— तमसा ज़ाहोला

बाह, 1000 और 3 के बिट्स ओवरलैप नहीं होते हैं। यह बहुत गलत लगता है।

— यक्क - एडम नेवरामोंट

बिट्स ओवरलैप करते हैं। लेकिन 1 का नहीं। : -]

— अमीन नेग्म-अवध

@ यक: वास्तव में, यह बहुत गलत लगता है! ... मुझे आशा है कि बहुत से लोग यह नहीं सोचेंगे कि "A ^ B" हमेशा A + B देता है (लेकिन मुझे कुछ डर लग सकता है ...)

— ओलिवियर Dulac

Answer 3

उपयोग न करने के कारण हैं 1000 * 1000 * 1000।

16-बिट के साथ int, 1000 * 1000ओवरफ्लो। तो उपयोग 1000 * 1000 * 1000पोर्टेबिलिटी कम कर देता है।

32-बिट के साथ int, कोड ओवरफ्लो की पहली पंक्ति है।

long long Duration = 1000 * 1000 * 1000 * 1000;  // overflow
long long Duration = 1000000000000;  // no overflow, hard to read

सुझाव दें कि मुख्य मूल्य पठनीयता, सुवाह्यता और शुद्धता के लिए गंतव्य के प्रकार से मेल खाता है ।

double Duration = 1000.0 * 1000 * 1000;
long long Duration = 1000LL * 1000 * 1000 * 1000;

इसके अलावा उन eमूल्यों के लिए सरल उपयोग संकेतन हो सकता है जो बिल्कुल एक के रूप में प्रतिनिधित्व करने योग्य हैं double। बेशक यह जानने के लिए कि क्या doubleपूरी संख्या मूल्य का प्रतिनिधित्व कर सकता है - 1e9 से अधिक मूल्यों के साथ चिंता का विषय। (देखें DBL_EPSILONऔर DBL_DIG)।

long Duration = 1000000000;
// vs.
long Duration = 1e9;

Comments

बहुत महत्वपूर्ण टिप्पणी! safecoding.cert.org/confluence/display/c/… बहुत सारे मामलों में मदद कर सकता है?

— ओलिवियर दुलाक

A doubleठीक 2 ^ 53 15 9e15 तक के सभी पूर्णांकों का प्रतिनिधित्व कर सकता है।

— एडगर बोनट

@EdgarBonet यह सच है कि बाइनरी 64 पूरी संख्या को लगभग 9e15 तक दर्शा सकता है। लेकिन सी doubleबाइनरी 64 के उपयोग को निर्दिष्ट नहीं करता है , भले ही यह बहुत ही सामान्य रूप से उपयोग किया जाता है। C कल्पना के अनुसार, 1e9 या इसके ऊपर के मान बिल्कुल प्रतिनिधित्व योग्य हैं। यह निर्भर करता है कि आप सामान्य व्यवहार पर अटकल लगाना या भरोसा करना चाहते हैं या नहीं।

— chux -

दोनों @Patrick 1000और 1000000000000कर रहे हैं स्थिरांक पूर्णांक । प्रत्येक स्वतंत्र रूप से चयनित प्रकार से है int, longया long long। संकलक उन 3 के पहले प्रकार का उपयोग करता है जिसमें पूर्णांक स्थिर फिट बैठता है। प्रत्येक में गणित के 1000 * 1000 * 1000 * 1000साथ किया जाता है । उत्पाद 32-बिट के साथ ओवरफ्लो होता है । निश्चित रूप से एक (या संभवतः संकीर्ण) के रूप में प्रतिनिधित्व करने योग्य है - कोई अतिप्रवाह नहीं। लक्ष्य का प्रकार इस "= के दाईं ओर" क्षति को प्रभावित नहीं करता है। int1000intint1000000000000long longlong long Duration

— chux -

गुणा में पहले व्यापक प्रकार का स्थान देना महत्वपूर्ण है। 16-बिट के साथ int, long x = 1000 * 1000 * 1000L;अतिप्रवाह होगा, जबकि long x = 1000L * 1000 * 1000;नहीं होगा।

— पूर्व निहिलो

Answer 4

पठनीयता के लिए।

शून्य ( 1 000 000 000या 1,000,000,000) के बीच अल्पविराम और रिक्त स्थान रखने से एक वाक्यविन्यास त्रुटि उत्पन्न होगी, और 1000000000कोड में होने से यह देखना कठिन हो जाता है कि कितने शून्य हैं।

1000*1000*1000यह स्पष्ट करता है कि यह 10 ^ 9 है, क्योंकि हमारी आँखें अधिक आसानी से विखंडू को संसाधित कर सकती हैं। इसके अलावा, कोई रनटाइम लागत नहीं है, क्योंकि कंपाइलर इसे निरंतर के साथ बदल देगा 1000000000।

Comments

FYI करें, अंक विभाजकों की एक अवधारणा है जिसे मैंने हाल ही में सीखा है। जावा के पास यह अभी थोड़ी देर के लिए है, और C # 7.0 इसे प्राप्त कर सकता है। काश सभी भाषाओं में यह आई-कैंडी सुविधा होती। :)

— iheartcsharp

इस संदर्भ के आधार पर 1,000,000,000वाक्य रचना त्रुटि का उत्पादन नहीं करेगी, इसका मतलब कुछ और होगा। उदाहरण के लिएCMTimeMakeWithSeconds( newDurationSeconds, 1,000,000,000 )

— रॉस रिज

@ JMS10 C # पहले से ही है अगर आप VS15 पूर्वावलोकन संस्करण स्थापित करते हैं, तो लिखा जा सकता है1_000_000_000

— user1306322

पायथन _विभाजक के रूप में मिल रहा है , भी :)

— वेन वर्नर

और C ++ को हाल ही में 'विभाजक, C ++ 14 में मिला है , ताकि आप उपयोग कर सकें 1'000'000'000। (यह चुना गया था क्योंकि 1,000,000,000अल्पविराम ऑपरेटर या 4 अलग मापदंडों के रूप में गलत व्याख्या की जा सकती है, और _1_000_000_000एक वैध (लेकिन शायद) चर नाम है।)

— जस्टिन टाइम -

Answer 5

पठनीयता के लिए। तुलना के लिए, जावा _पठनीयता में सुधार करने के लिए नंबरों का समर्थन करता है (पहले स्टीफन कोलबोर्न द्वारा प्रस्तावित डेरेक फोस्टर के PROPOSAL के जवाब के रूप में : प्रोजेक्ट सिक्का / JSR 334 के लिए द्विआधारी साहित्य )। एक 1_000_000_000यहाँ लिखेंगे ।

मोटे तौर पर कालानुक्रमिक क्रम में, सबसे पुराने समर्थन से नवीनतम तक:

• XPL: "(1)1111 1111"( स्पष्ट रूप से दशमलव मानों के लिए नहीं, केवल द्विआधारी, क्वार्टल, ऑक्टल या हेक्साडेसिमल मूल्यों का प्रतिनिधित्व करने वाले बिटस्ट्रिंग्स के लिए )
• पी एल / एम: 1$000$000
• एडीए: 1_000_000_000
• पर्ल: इसी तरह
• रूबी: इसी तरह
• फैंटम (पहले वाला फैन): इसी तरह
• जावा 7: इसी तरह
• स्विफ्ट: (वही)
• अजगर 3.6
• सी ++ 14: 1'000'000'000

यह भाषाओं के लिए एक अपेक्षाकृत नई विशेषता है कि उन्हें यह महसूस करना चाहिए कि उन्हें समर्थन करना चाहिए (और फिर पर्ल है)। जैसा कि chux @ के उत्कृष्ट उत्तर में है, 1000*1000...एक आंशिक समाधान है, लेकिन प्रोग्रामर को बग से गुणा करके खोलता है भले ही अंतिम परिणाम एक बड़े प्रकार का हो।

Comments

कई आधुनिक प्रोग्रामिंग भाषाओं में समान हैं, जैसे स्विफ्ट। कुछ नया नहीं।

— सुल्तान

AFAIK, यह पर्ल से आता है। PL / M ने समान उद्देश्य के लिए $ का उपयोग किया, उदाहरण के लिए: 0100 $ 0010B

— ninjalj

यह है काफी नई है, हालांकि। जावा फीचर शायद 5 साल पुराना है। इस सिंटैक्स का समर्थन करने वाली अधिकांश अन्य भाषाएँ बहुत नई हैं - स्विफ्ट खुद कुछ साल पुरानी है। अजगर 3.6 में समर्थन जोड़ता है, जो अभी तक जारी नहीं किया गया है।

— 3

अडा ने 33 वर्षों के लिए पूर्णांक शाब्दिक अर्थों में रेखांकित किया है।

— पीटर -

@djechlin: मैंने कालानुक्रमिक क्रम में, अधिक जानकारी जोड़ने की स्वतंत्रता ली है। मैं पहले गलत था, प्रोजेक्ट कॉइन के धागे को देखते हुए, स्टीफन कोलबोर्न ने शायद फैंडेरियम और / या रूबी से पूर्णांक शाब्दिक में अंडरस्कोर का विचार लिया। रूबी ने शायद पर्ल से, और पर्ल ने अदा से विचार लिया।

— नवजाल

Answer 6

1,000,000,000फार्म के साथ कुछ संघों को पढ़ने और प्राप्त करने के लिए सरल हो सकता है ।

तकनीकी पहलू से मुझे लगता है कि प्रत्यक्ष संख्या या गुणन में कोई अंतर नहीं है। कंपाइलर इसे वैसे भी निरंतर अरब संख्या के रूप में उत्पन्न करेगा।

यदि आप ऑब्जेक्टिव-सी के बारे में बात करते हैं, तो 1000^3काम नहीं करेगा क्योंकि पाउ के लिए ऐसा कोई सिंटैक्स नहीं है (यह xor है)। इसके बजाय, pow()फ़ंक्शन का उपयोग किया जा सकता है। लेकिन उस मामले में, यह इष्टतम नहीं होगा, यह एक रनटाइम फ़ंक्शन कॉल होगा जो संकलित निरंतर उत्पन्न नहीं करेगा।

Answer 7

कारणों का वर्णन करने के लिए निम्नलिखित परीक्षण कार्यक्रम पर विचार करें:

$ cat comma-expr.c && gcc -o comma-expr comma-expr.c && ./comma-expr
#include <stdio.h>

#define BILLION1 (1,000,000,000)
#define BILLION2 (1000^3)

int main()
{
        printf("%d, %d\n", BILLION1, BILLION2);
}
0, 1003
$

Comments

@pjvandehaar मैं विकिपीडिया लेखों को पढ़कर भाषा सीखने की सिफारिश नहीं करूँगा।

— पीटर -

Answer 8

दशमलव संख्याओं के लिए C में समान प्रभाव प्राप्त करने का एक और तरीका शाब्दिक फ़्लोटिंग पॉइंट नोटेशन का उपयोग करना है - इसलिए जब तक कि आप सटीकता के किसी भी नुकसान के बिना वांछित संख्या का प्रतिनिधित्व कर सकते हैं।

IEEE 754 64-बिट डबल समस्या के बिना किसी भी गैर-नकारात्मक पूर्णांक <= 2 ^ 53 का प्रतिनिधित्व कर सकता है। आमतौर पर, लंबी डबल (80 या 128 बिट) इससे भी आगे जा सकती हैं। रूपांतरण संकलन के समय पर किया जाएगा, इसलिए कोई रनटाइम ओवरहेड नहीं है और आपको सटीक रूप से अप्रत्याशित नुकसान होने पर चेतावनी मिल सकती है और आपके पास एक अच्छा संकलक है।

long lots_of_secs = 1e9;